Initial Commit

OMChem(OMchemSim-python api) is designed by Rahul Jain, Simulator is taken from https://github.com/FOSSEE/OMChemSim and GUI related things are implemented during FOSSEE Summer Fellowship 2019 by Anosh Billimoria and Anuj Goyal

32 files changed, 1862 insertions, 0 deletions

diff --git a/OMChem/CompSep.py b/OMChem/CompSep.py
new file mode 100644
index 0000000..54b6415
--- /dev/null
+++ b/OMChem/CompSep.py
@@ -0,0 +1,63 @@
+from OMChem.EngStm import EngStm
+import json
+class CompSep():
+    def __init__(self,CompNames = [],name='compoundseparator',SepFact=['Molar_Flow','Mass_Flow'],SepStrm=1,SepFactValue=[]):
+        self.SepFact = json.dumps(SepFact).replace('[','{').replace(']','}')
+        self.SepStrm = str(SepStrm)
+        self.SepFactValue = json.dumps(SepFactValue).replace('[','{').replace(']','}')
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = []
+        self.OutputStms = []
+        self.type = 'CompSep'
+        self.EngStms = EngStm(name='EngStm')
+
+    def modesList(self):
+        return []   
+    def paramgetter(self,mode=None):
+        dict = {"SepStrm":None,"SepFactValue":None,"SepFact":None}
+        return dict
+
+    def paramsetter(self,dict):
+        self.SepStrm = dict['SepStrm']
+        self.SepFactValue = dict['SepFactValue']
+        self.SepFact = dict['SepFact']
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Compound_Separator " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + ("sepFact = "+self.SepFact+",sepStrm = " + self.SepStrm + ", sepFactVal = " + self.SepFactValue + ");\n")
+
+        return self.OM_data_init
+
+    def connect(self,InputStms = None,OutputStms = []):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        comp_count = len(addedcomp)
+        strcount = 1
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' + self.name + '.inlet' + ');\n')
+            
+        for strm in self.OutputStms:
+            self.OM_data_eqn = self.OM_data_eqn + ('connect(' + strm.name + '.inlet,' + self.name + '.outlet'+str(strcount)+');\n')
+            strcount += 1
+        
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,' + self.name + '.energy);\n')
+        sepFac = str(self.SepFactValue).strip('[').strip(']')
+
+        self.OM_data_eqn = self.OM_data_eqn + (self.name+'.sepFactVal= {'+ sepFac + '};\n')
+        
+
+        return self.OM_data_eqn
+
diff --git a/OMChem/ConvReactor.py b/OMChem/ConvReactor.py
new file mode 100644
index 0000000..b9958a9
--- /dev/null
+++ b/OMChem/ConvReactor.py
@@ -0,0 +1,80 @@
+import json
+from OMChem.EngStm import EngStm
+class ConvReactor():
+    def __init__(self,name='',Nr=None,b=None,X=None,Z=None,a=[],operation=None,Tdef=None):
+        self.Nr = str(Nr)
+        self.b = str(b)
+        self.X = str(X)
+        self.Z = str(Z)
+        self.a = json.dumps(a).replace('[','{').replace(']','}')
+        self.operation = str(operation)
+        self.Tdef = str(Tdef)
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = []
+        self.OutputStms = []
+        self.type = 'ConvReactor'
+        self.EngStms = EngStms(name="EngStm")
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + ( "Simulator.Unit_Operations.ConversionReactor " + self.name + "(Nr = " + self.Nr + ',b = ' + self.b + ',X = ' + self.X + ',Z = ' + self.Z + ',a = ' + self.a + ',operation = ' + self.operation + ',Tdef = ' + self.Tdef + ');\n')
+        return self.OM_data_init
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        comp_count = len(addedcomp)
+        strcount = 1
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' + self.name + '.inlet' + ');\n')
+            
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.OutputStms[0].name + '.inlet,' + self.name + '.outlet);\n')
+            
+
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.inlet,' + self.name + '.EnergyStream);\n')
+
+        return self.OM_data_eqn
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/OMChem/Cooler.py b/OMChem/Cooler.py
new file mode 100644
index 0000000..577b181
--- /dev/null
+++ b/OMChem/Cooler.py
@@ -0,0 +1,66 @@
+from OMChem.EngStm import EngStm
+class Cooler():
+    def __init__(self,name='cooler',PressureDrop = None, eff = None):
+        self.PressureDrop = PressureDrop
+        self.eff = eff
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        #self.heatRem = heatRem
+        self.EngStms = EngStm(name='EngStm')
+        self.type = 'Cooler'
+        self.mode = None
+        self.modeVal = None
+
+        self.Prop = {
+                'pressDrop':None,
+                'eff':None,
+                'outT':None,
+                'tempDrop':None,
+                'heatRem':None,
+            }
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["heatRem","outT","outVapPhasMolFrac","tempDrop","enFlo"]
+
+    def paramgetter(self,mode="heatRem"):
+        self.mode = mode
+        dict = {"PressureDrop":None,"eff":None,self.mode:None}
+        return dict
+
+    def paramsetter(self,dict):
+        
+        self.PressureDrop = dict['PressureDrop']
+        self.eff = dict['eff']
+        self.modeVal = dict[self.mode]
+        
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Cooler " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + 'pressDrop = ' + str(self.PressureDrop) + ','
+        self.OM_data_init = self.OM_data_init + 'eff = ' + str(self.eff) + ');\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,'+ self.name + '.energy);\n')
+        if(self.mode =="enFlo"):
+            self.OM_data_eqn = self.OM_data_eqn + (self.EngStms.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        else:    
+            self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        return self.OM_data_eqn
\ No newline at end of file
diff --git a/OMChem/DistCol.py b/OMChem/DistCol.py
new file mode 100644
index 0000000..35054da
--- /dev/null
+++ b/OMChem/DistCol.py
@@ -0,0 +1,95 @@
+from OMChem.EngStm import EngStm
+class DistCol():
+    def __init__(self,name=('DistCol',1), numStage = None,numFeeds = None,feedStages = None):
+        self.numStage = numStage
+        self.numFeeds=numFeeds
+        self.feedStages=feedStages
+        self.name = name[0]
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.EngStm1 = EngStm(name='EngStm1'+self.name)
+        self.EngStm2 = EngStm(name='EngStm2'+self.name)
+        self.count = name[1]
+        self.thermoPackage='Raoults_Law'
+        self.type = 'DistCol'
+        self.mode = None
+        self.condType=''
+        self.modeVal = None
+        self.condP=None
+        self.rebP=None
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["refluxRatio","sideDrawMolFlo","T"]
+
+    def paramgetter(self,mode="refluxRatio"):
+        self.mode=mode
+        dict = { "numStage" : None,"numFeeds" :None,"feedStages" :None,"thermoPackage":None,"condType":None,self.mode:None,"condensor.P":None,"reboiler.P":None}
+        return dict
+        
+    def paramsetter(self,dict):
+        self.numStage = dict["numStage"]
+        self.numFeeds = dict["numFeeds"]
+        self.feedStages = dict["feedStages"].split(",")
+        self.modeVal=dict[self.mode]
+        self.condP=dict["condensor.P"]
+        self.rebP=dict["reboiler.P"]
+        self.condType=dict["condType"]
+  
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + 'model Condensor\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Unit_Operations.Distillation_Column.Cond;\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Files.Thermodynamic_Packages.'+self.thermoPackage+';\n'
+        self.OM_data_init = self.OM_data_init + 'end Condensor;\n'
+        self.OM_data_init = self.OM_data_init + 'model Tray\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Unit_Operations.Distillation_Column.DistTray;\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Files.Thermodynamic_Packages.'+self.thermoPackage+';\n'
+        self.OM_data_init = self.OM_data_init + 'end Tray;\n'
+        self.OM_data_init = self.OM_data_init + 'model Reboiler\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Unit_Operations.Distillation_Column.Reb;\n'
+        self.OM_data_init = self.OM_data_init + 'extends Simulator.Files.Thermodynamic_Packages.'+self.thermoPackage+';\n'
+        self.OM_data_init = self.OM_data_init + 'end Reboiler;\n'
+        self.OM_data_init = self.OM_data_init + ("model distCol"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Unit_Operations.Distillation_Column.DistCol;\n" )
+        self.OM_data_init = self.OM_data_init + ("Condensor condensor(NOC = NOC, comp = comp, condType =condType, boolFeed = boolFeed[1], T(start = 300));\n" )
+        self.OM_data_init = self.OM_data_init + ("Reboiler reboiler(NOC = NOC, comp = comp, boolFeed = boolFeed[noOfStages]);\n" )
+        self.OM_data_init = self.OM_data_init + ("Tray tray[noOfStages - 2](each NOC = NOC, each comp = comp, boolFeed = boolFeed[2:noOfStages -1]);\n" )
+        self.OM_data_init = self.OM_data_init + ("end distCol"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "distCol"+str(self.count)+" "+ self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.feedStages=str(self.feedStages).strip('[').strip(']')
+        self.feedStages = self.feedStages.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")+("noOfStages="+self.numStage+","+"noOfFeeds="+self.numFeeds+",feedStages="+"{"+self.feedStages+"}"+",condensor.condType="+"\""+self.condType+"\""+");\n")
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStm1.name+';\n'
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStm2.name+';\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect('+self.name+'.'+'condensor_duty'+','+ self.EngStm1.name+'.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect('+self.name+'.reboiler_duty'+', '+self.EngStm2.name+'.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect('+self.name+'.distillate'+", "+self.OutputStms[0].name+'.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect('+self.name+'.bottoms'+", "+self.OutputStms[1].name+'.inlet);\n')
+        for i in range(len(self.InputStms)):
+            self.OM_data_eqn = self.OM_data_eqn + ('connect('+self.InputStms[i].name+'.outlet'+", "+self.name+'.feed['+str(i+1)+']);\n')
+        self.OM_data_eqn = self.OM_data_eqn + (self.OutputStms[1].name+'.'+'totMolFlow[1] = '+str(self.OutputStms[1].Prop['totMolFlo[1]'])+';\n')
+        if self.mode=="refluxRatio":
+            self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+str(self.mode)+'='+ str(self.modeVal) + ';\n')
+        else:
+            self.OM_data_eqn = self.OM_data_eqn + (self.name+'.condensor.'+self.mode+'='+ str(self.modeVal) + ';\n')
+        
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.reboiler.P='+self.rebP+';\n'
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.condensor.P='+self.condP+';\n'
+        return self.OM_data_eqn
+        
diff --git a/OMChem/EngStm.py b/OMChem/EngStm.py
new file mode 100644
index 0000000..cf938ad
--- /dev/null
+++ b/OMChem/EngStm.py
@@ -0,0 +1,18 @@
+
+class EngStm():
+    
+    def __init__(self,name = 'Engstm'):
+        self.name = name
+        self.type = 'EngStm'
+        self.OM_data_init = ''
+        self.OM_data_eqn = ''
+
+
+    def OM_Flowsheet_Init(self,addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.name+';\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self,addedcomp):
+    	self.OM_data_eqn = ''
+    	return self.OM_data_eqn
diff --git a/OMChem/Flash.py b/OMChem/Flash.py
new file mode 100644
index 0000000..22335a5
--- /dev/null
+++ b/OMChem/Flash.py
@@ -0,0 +1,45 @@
+class Flash():
+    def __init__(self,name=("flash",1)):
+        self.name = name[0]
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.type = 'flash'
+        self.count = name[1]
+        self.thermoPackage =None
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return []   
+
+    def paramgetter(self,mode=None):
+        dict = {"thermoPackage":None}
+        return dict
+    def paramsetter(self,dict):
+        self.thermoPackage = dict['thermoPackage']
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + ("model fls"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Unit_Operations.Flash;\n" )
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Files.Thermodynamic_Packages."+self.thermoPackage+";\n")
+        self.OM_data_init = self.OM_data_init + ("end fls"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "fls"+str(self.count)+" "+ self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("});\n")
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        comp_count = len(addedcomp)
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' + self.name + '.feed' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.vapor,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.liquid,' + self.OutputStms[1].name + '.inlet);\n')
+        return self.OM_data_eqn
\ No newline at end of file
diff --git a/OMChem/Flowsheet.py b/OMChem/Flowsheet.py
new file mode 100644
index 0000000..35c6d0a
--- /dev/null
+++ b/OMChem/Flowsheet.py
@@ -0,0 +1,467 @@
+# from OMPython import OMCSession
+import os
+import csv
+from subprocess import Popen, PIPE
+#import subprocess
+import pandas as pd
+
+class Flowsheet():
+	def __init__(self):
+		self.sim_name = 'Simulator'
+		self.sim_method = ''
+		self.UnitOpn = []
+		self.data = []
+		self.compounds = []
+		self.interface = ''
+		self.omc_path = None
+		self.curr_path = os.getcwd()
+		self.sim_dir_path = os.path.join(self.curr_path, self.sim_name)
+		self.Flomo_path = os.path.join(self.sim_dir_path,'Flowsheet.mo')
+		self.eqn_mos_path = os.path.join(self.sim_dir_path,'simulateEQN.mos')
+		self.sm_mos_path = os.path.join(self.sim_dir_path,'simulateSM.mos')
+		self.resdata = []
+		self.stdout=None
+		self.stderr=None
+	
+	
+	def get_omc_path(self):
+		try:
+		    self.omhome = os.environ.get('OPENMODELICAHOME')
+		    if self.omhome is None:
+		        self.omhome = os.path.split(os.path.split(os.path.realpath(spawn.find_executable("omc")))[0])[0]
+		    elif os.path.exists('/opt/local/bin/omc'):
+		        self.omhome = '/opt/local'
+		    return os.path.join(self.omhome, 'bin', 'omc')
+		except BaseException:
+		    print("The OpenModelica compiler is missing in the System path please install it" )
+		    raise
+
+	def add_UnitOpn(self,unitop,flag):
+                f=(unitop,flag)
+                self.UnitOpn.append(f)
+	def remove_UnitOpn(self,unitop):
+		self.UnitOpn.remove(unitop)
+
+	def add_comp_list(self,comp):
+		self.compounds = comp
+	
+
+	def send_for_simulationEqn(self):
+		self.resdata = []
+		self.omc_path = self.get_omc_path()
+		print(self.omc_path)
+
+		if self.sim_method == 'Eqn':
+			simpath = self.eqn_mos_path
+			os.chdir(self.sim_dir_path)
+			
+			process = Popen([self.omc_path, '-s',simpath], stdout=PIPE, stderr=PIPE)
+			self.stdout, self.stderr = process.communicate()
+			#s = subprocess.check_output([self.omc_path, '-s',simpath])
+			#print(s)
+			#print("############### StdOut ################")
+			print(self.stdout)
+			os.chdir(self.curr_path)
+			#os.system(self.omc_path + ' -s ' + simpath)
+			print("Hello")
+		if self.sim_method == 'Eqn':
+			print("hhhh")
+			csvpath = os.path.join(self.sim_dir_path,'Flowsheet_res.csv')
+			print("csvPath",csvpath)
+			with open (csvpath,'r') as resultFile:
+				self.resdata = []
+				print("opened")
+				csvreader = csv.reader(resultFile,delimiter=',')
+				for row in csvreader:
+					print("124125")
+					self.resdata.append(row)
+			#self.ExtData()
+	
+
+	def send_for_simulationSM(self,unitop):
+
+		self.resdata = []
+		self.omc_path = self.get_omc_path()
+		os.chdir(self.sim_dir_path)
+		#os.system(self.omc_path + ' -s ' + unitop.name+'.mos')
+		process = Popen([self.omc_path, '-s',unitop.name,'.mos'], stdout=PIPE, stderr=PIPE)
+		stdout, stderr = process.communicate()
+		#s = subprocess.check_output([self.omc_path, '-s',simpath])
+		#print(s)
+		print("############### StdOut ################")
+		print(stdout)
+		self.resdata = []
+		print('Simulating '+unitop.name+'...')
+		csvpath = os.path.join(self.sim_dir_path,unitop.name+'_res.csv')
+		with open(csvpath,'r') as resultFile:
+			csvreader = csv.reader(resultFile,delimiter=',')
+			for row in csvreader:
+				self.resdata.append(row)
+		self.ExtData()
+
+		
+
+		
+
+		# if self.sim_method == 'SM':
+		# 	for unitop in self.UnitOpn:
+		# 		self.resdata = []
+		# 		if unitop.type != 'MatStm':
+		# 			print 'Simulating '+unitop.name+'...'
+		# 			csvpath = os.path.join(self.sim_dir_path,unitop.name+'_res.csv')
+		# 			with open(csvpath,'r') as resultFile:
+		# 				csvreader = csv.reader(resultFile,delimiter=',')
+		# 				for row in csvreader:
+		# 					self.resdata.append(row)
+		# 			self.ExtData()
+
+
+		
+			
+
+		# if self.interface == 'OMPython':
+		# 	omc = OMCSession()
+		# 	omc.sendExpression("loadModel(Modelica)")
+		# 	omc.sendExpression("loadFile(\"Simulator.mo\")")
+		# 	omc.sendExpression("loadFile(\"Flowsheet.mo\")")
+		# 	execsim = omc.sendExpression("simulate(Flowsheet, outputFormat=\"csv\", stopTime=1.0, numberOfIntervals=1)")
+		
+		# else:
+		# 	os.system(self.omc_path + ' -s  ')
+
+	def ExtData(self):
+		for unit in self.UnitOpn:
+			if unit[0].type == 'MatStm':
+#
+				for key, value in unit[0].Prop.items():
+
+				
+					propertyname = unit[0].name + '.' + key
+					if propertyname in self.resdata[0]:
+						ind = self.resdata[0].index(propertyname)
+						resultval = str(self.resdata[-1][ind])
+		 				#resultval = str(omc.sendExpression("val("+unit.name+ "." + value + ", 0.5)"))
+						print(resultval)
+						unit[0].Prop[key] = resultval
+				#print(unit[0].Prop)
+			# 		else:
+			# 			for v in value:
+			# 				propertyname = unit.name + '.' + v
+			# 				if propertyname in self.resdata[0]:
+			# 					ind = self.resdata[0].index(propertyname)
+			# 					resultval = str(self.resdata[-1][ind])
+			# # 					resultval = str(omc.sendExpression("val("+unit.name+ "." + v + ", 0.5)"))
+			# 					unit.Prop[key][i] = resultval
+			# 					i = i + 1
+
+			# 	for key, value in unit.OMVapProp.iteritems():
+			# 		i = 0
+
+			# 		if type(value) is str:
+			# 			propertyname = unit.name + '.' + value
+			# 			if propertyname in self.resdata[0]:
+			# 				ind = self.resdata[0].index(propertyname)
+			# 				resultval = str(self.resdata[-1][ind])
+			# # 				resultval = str(omc.sendExpression("val("+unit.name+ "." + value + ", 0.5)"))
+			# 				unit.VapProp[key] = resultval
+			# 		else:
+			# 			for v in value:
+			# 				propertyname = unit.name + '.' + v
+			# 				if propertyname in self.resdata[0]:
+			# 					ind = self.resdata[0].index(propertyname)
+			# 					resultval = str(self.resdata[-1][ind])
+			# # 					resultval = str(omc.sendExpression("val("+unit.name+ "." + v + ", 0.5)"))
+			# 					unit.VapProp[key][i] = resultval
+			# 					i = i + 1
+
+
+			# 	for key, value in unit.OMLiqProp.iteritems():
+			# 		i = 0
+
+			# 		if type(value) is str:
+			# 			propertyname = unit.name + '.' + value
+			# 			if propertyname in self.resdata[0]:
+			# 				ind = self.resdata[0].index(propertyname)
+			# 				resultval = str(self.resdata[-1][ind])
+			# # 				resultval = str(omc.sendExpression("val("+unit.name+ "." + value + ", 0.5)"))
+			# 				unit.LiqProp[key] = resultval
+			# 		else:
+			# 			for v in value:
+			# 				propertyname = unit.name + '.' + v
+			# 				if propertyname in self.resdata[0]:
+			# 					ind = self.resdata[0].index(propertyname)
+			# 					resultval = str(self.resdata[-1][ind])
+			# # 					resultval = str(omc.sendExpression("val("+unit.name+ "." + v + ", 0.5)"))
+			# 					unit.LiqProp[key][i] = resultval
+			# 					i = i + 1
+		# 		for key, value in unit.OMVapProp.iteritems():
+		# 			i = 0
+
+		# 			if type(value) is str:
+		# 				resultval = str(omc.sendExpression("val("+unit.name+ "." + value + ", 0.5)"))
+		# 				unit.VapProp[key] = resultval
+		# 			else:
+		# 				for v in value:
+		# 					resultval = str(omc.sendExpression("val("+unit.name+ "." + v + ", 0.5)"))
+		# 					unit.VapProp[key][i] = resultval
+		# 					i = i + 1
+
+
+		# 		for key, value in unit.OMLiqProp.iteritems():
+		# 			i = 0
+
+		# 			if type(value) is str:
+		# 				resultval = str(omc.sendExpression("val("+unit.name+ "." + value + ", 0.5)"))
+		# 				unit.LiqProp[key] = resultval
+		# 			else:
+		# 				for v in value:
+		# 					resultval = str(omc.sendExpression("val("+unit.name+ "." + v + ", 0.5)"))
+		# 					unit.LiqProp[key][i] = resultval
+		# 					i = i + 1       	
+
+
+
+	def simulateEQN(self):
+		self.data = []
+		print("##################################################")
+		print("##################################################")
+		self.sim_method = 'Eqn'
+		self.data.append("model Flowsheet\n")
+  		
+		for c in self.compounds:
+			ucase = c.title()
+			lcase = c.lower()
+			self.data.append("parameter Simulator.Files.Chemsep_Database." + ucase +' '+ ucase + "; \n")
+
+		for unitop in self.UnitOpn:
+			self.data.append(unitop[0].OM_Flowsheet_Init(self.compounds))
+		
+		self.data.append("equation\n")
+        
+		for unitop in self.UnitOpn:
+			if unitop[1]==0:
+					
+				if unitop[0].type == 'MatStm':
+					self.data.append(unitop[0].OM_Flowsheet_Eqn(self.compounds,'Eqn'))
+				else:
+					self.data.append(unitop[0].OM_Flowsheet_Eqn(self.compounds))
+			else:
+				pass
+		with open(self.Flomo_path, 'w') as txtfile:
+			for d in self.data:
+				txtfile.write(d)
+			txtfile.write('end Flowsheet;\n')
+
+		with open(self.eqn_mos_path, 'w') as mosFile:
+			mosFile.write('loadModel(Modelica);\n')
+			mosFile.write("loadFile(\"Simulator\package.mo\");\n")
+			mosFile.write("loadFile(\"Flowsheet.mo\");\n")
+			mosFile.write("simulate(Flowsheet, outputFormat=\"csv\", stopTime=1.0, numberOfIntervals=1);\n")
+
+		print('Initiating Simulation in Equation Oriented Mode')
+
+		self.send_for_simulationEqn()
+
+	
+
+
+	def simulateSM(self,ip,op):
+		self.sim_method = 'SM'
+		self.data = []
+		self.resdata = []
+		self.unit = []
+		self.csvlist = []
+		print("op list",op)
+		print("ip list",ip)
+		for i in ip:
+			common = ip[i]
+			print("common #############3",common)
+			print("*********** i *********",i)
+			for k,v in op.items():
+				print("Print K",k)
+				if(set(v) & set(common)):
+					print("*****************common matstm***************")
+					if((i in self.unit) and (k in self.unit)):
+						print("both exist")
+						pass
+					elif(i in self.unit):
+						print("output exist")
+						self.unit.insert(self.unit.index(i),k)
+					elif(k in self.unit):
+						print("input exists")
+						self.unit.append(i)
+					else:
+						print("nothing exists")
+						self.unit.append(k)
+						self.unit.append(i)
+			print("##############################33")
+			print(self.unit)
+			print("################################11")	
+				
+		for unitop in self.unit:
+			os.chdir(self.curr_path)
+			self.data = []
+			if unitop.type not in ['MatStm','EngStm']:
+				inpstms = unitop.InputStms
+				outstms = unitop.OutputStms
+				
+				try:
+					engstms = unitop.EngStms
+				except:
+					engstms = None
+
+				self.data.append("model "+unitop.name.lower()+'\n')
+				
+				for c in self.compounds:
+					ucase = c.title()
+					lcase = c.lower()
+					self.data.append("parameter Simulator.Files.Chemsep_Database." + ucase +' '+ ucase + "; \n")
+				
+				print("##############compounds added")
+				self.data.append(unitop.OM_Flowsheet_Init(self.compounds))
+				
+				if type(outstms) is list:
+					for stm in outstms:
+						self.data.append(stm.OM_Flowsheet_Init(self.compounds))
+				else:
+					self.data.append(outstms.OM_Flowsheet_Init(self.compounds))
+				
+				
+				if engstms:
+					self.data.append(engstms.OM_Flowsheet_Init(self.compounds))
+
+				if type(inpstms) is list:
+					for stm in inpstms:
+						self.data.append(stm.OM_Flowsheet_Init(self.compounds))
+				else:
+					self.data.append(inpstms.OM_Flowsheet_Init(self.compounds))
+				
+				self.data.append('equation\n')
+				print("##################equation")
+				self.data.append(unitop.OM_Flowsheet_Eqn(self.compounds))
+				'''
+				if type(outstms) is list:
+					for stm in outstms:
+						#stm.GetEquationValues()
+						self.data.append(stm.OM_Flowsheet_Eqn(self.compounds,'SM'))
+				else:
+					#outstms.GetEquationValues()
+					self.data.append(outstms.OM_Flowsheet_Eqn(self.compounds,'SM'))
+'''
+				if type(inpstms) is list:
+					for stm in inpstms:
+						#stm.GetEquationValues()
+						self.data.append(stm.OM_Flowsheet_Eqn(self.compounds,'SM'))
+				else:
+					#inpstms.GetEquationValues()
+					self.data.append(inpstms.OM_Flowsheet_Eqn(self.compounds,'SM'))
+
+				# os.chdir(self.sim_dir_path)
+				unitmofile = os.path.join(self.sim_dir_path,unitop.name.lower()+'.mo')
+
+				with open(unitmofile,'w') as unitFile:
+					for d in self.data:
+						unitFile.write(d)
+					unitFile.write('end '+unitop.name.lower()+';\n')
+				
+				unitmosfile = os.path.join(self.sim_dir_path,unitop.name.lower()+'.mos')
+				with open(unitmosfile, 'w') as mosFile:
+					mosFile.write('loadModel(Modelica);\n')
+					mosFile.write("loadFile(\"Simulator\package.mo\");\n")
+				
+					mosFile.write("loadFile(\""+unitop.name.lower()+".mo\");\n")
+					mosFile.write("simulate("+unitop.name.lower()+", outputFormat=\"csv\", stopTime=1.0, numberOfIntervals=1);\n")
+
+				print("Initiating simulation in Sequential Modular Mode")
+				#self.resdata = []
+				self.omc_path = self.get_omc_path()
+				os.chdir(self.sim_dir_path)
+				#os.system(self.omc_path + ' -s ' + unitop[0].name.lower()+"SEQ"+'.mos')
+				print("SIM directory Path 1 ###",self.sim_dir_path)
+				sim = os.path.join(self.sim_dir_path,unitop.name.lower()+'.mos')
+				process = Popen([self.omc_path, '-s',sim], stdout=PIPE, stderr=PIPE)
+				self.stdout, self.stderr = process.communicate()
+				os.chdir(self.curr_path)
+				#s = subprocess.check_output([self.omc_path, '-s',simpath])
+				#print(s)
+				print("############### StdOut ################")
+				print(self.stdout)
+				print("############### StdErr ################")
+				print(self.stderr)
+				print('Simulating '+unitop.name.lower()+'...')
+				csvpath = os.path.join(self.sim_dir_path,unitop.name.lower()+'_res.csv')
+				
+				self.csvlist.append(csvpath)
+				
+				with open(csvpath,'r') as resultFile:
+					csvreader = csv.reader(resultFile,delimiter=',')
+					for row in csvreader:
+						self.resdata.append(row)
+				
+				os.chdir(self.curr_path)
+				if type(inpstms) is list:
+					for stm in inpstms:
+						for key, value in stm.Prop.items():
+							propertyname = stm.name + '.' + key
+							if propertyname in self.resdata[0]:
+								ind = self.resdata[0].index(propertyname)
+								resultval = str(self.resdata[-1][ind])
+								stm.Prop[key] = resultval
+
+								#print("input",stm.Prop[key])
+						
+
+				else:
+					for key, value in inpstms.Prop.items():
+							propertyname = inpstms.name + '.' + key
+							if propertyname in self.resdata[0]:
+								ind = self.resdata[0].index(propertyname)
+								resultval = str(self.resdata[-1][ind])
+								inpstms.Prop[key] = resultval
+								#print("input",inpstms.Prop[key])
+
+				if type(outstms) is list:
+					for stm in outstms:
+						for key, value in stm.Prop.items():
+							propertyname = stm.name + '.' + key
+							if propertyname in self.resdata[0]:
+								ind = self.resdata[0].index(propertyname)
+								resultval = str(self.resdata[-1][ind])
+								stm.Prop[key] = resultval
+								print("output key:",key,"value:",stm.Prop[key])
+				else:
+					for key, value in outstms.Prop.items():
+							propertyname = outstms.name + '.' + key
+							if propertyname in self.resdata[0]:
+								ind = self.resdata[0].index(propertyname)
+								resultval = str(self.resdata[-1][ind])
+								outstms.Prop[key] = resultval
+								print("output key:",key,"value:",outstms.Prop[key])
+
+		
+		self.dataframes = [pd.read_csv(i) for i in self.csvlist]
+		os.chdir(self.sim_dir_path)
+		dffinal = pd.concat(self.dataframes,axis=1)
+		dffinal.to_csv('FlowsheetSEQ.csv',index=False)
+		self.resdata.clear()
+		with open(os.path.join(self.sim_dir_path+'/FlowsheetSEQ.csv'),'r') as resultFile:
+					csvreader = csv.reader(resultFile,delimiter=',')
+					for row in csvreader:
+						self.resdata.append(row)
+		
+		
+
+
+				
+
+					
+				
+
+
+
+
+
+
+
+
+
diff --git a/OMChem/Heater.py b/OMChem/Heater.py
new file mode 100644
index 0000000..c0d8d95
--- /dev/null
+++ b/OMChem/Heater.py
@@ -0,0 +1,69 @@
+from OMChem.EngStm import EngStm
+class Heater():
+    def __init__(self,name='Heater',PressureDrop = None, eff = None):
+        self.PressureDrop = PressureDrop
+        self.eff = eff
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        #self.heatAdd=heatAdd
+        #self.outT = outT
+        self.OutputStms = None
+        self.EngStms = EngStm(name='EngStm'+name)
+        self.type = 'Heater'
+        self.mode = None
+        self.modeVal = None
+
+        self.Prop = {
+                'pressDrop':None,
+                'eff':None,
+                'outT':None,
+                'tempInc':None,
+                'heatAdd':None,
+            }
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["heatAdd","outT","outVapPhasMolFrac","tempInc","enFlo"]
+
+    def paramgetter(self,mode="heatAdd"):
+        self.mode = mode
+        dict = {"PressureDrop":None,"eff":None,self.mode:None}
+        return dict
+        
+    def paramsetter(self,dict):
+        
+        self.PressureDrop = dict['PressureDrop']
+        self.eff = dict['eff']
+        self.modeVal = dict[self.mode]
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Heater " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + 'pressDrop = ' + str(self.PressureDrop) +','
+        self.OM_data_init = self.OM_data_init + 'eff = ' + str(self.eff) + ');\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,' + self.name + '.energy);\n')
+
+        if(self.mode =="enFlo"):
+            self.OM_data_eqn = self.OM_data_eqn + (self.EngStms.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        else:    
+            self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        return self.OM_data_eqn
diff --git a/OMChem/MatStm.py b/OMChem/MatStm.py
new file mode 100644
index 0000000..6a3d814
--- /dev/null
+++ b/OMChem/MatStm.py
@@ -0,0 +1,500 @@
+from OMPython import OMCSession
+import json
+import sys
+from collections import defaultdict
+
+class MatStm():
+    def __init__(self,name =None,CompNames = [],Temperature=300,Pressure=101325,VapPhasMolFrac=None,VapPhasMasFrac=None,LiqPhasMolFrac=None,LiqPhasMasFrac=None,CompMolFrac = [1.0], CompMasFrac = [], MolFlow=100, MasFlow=None,**kwargs):
+        self.name = name[0]
+        self.type = 'MatStm'
+        self.T = Temperature
+        self.P = Pressure
+        self.VapPhasMolFrac = VapPhasMolFrac
+        self.VapPhasMasFrac =  VapPhasMasFrac
+        self.LiqPhasMolFrac = LiqPhasMolFrac
+        self.LiqPhasMasFrac = LiqPhasMasFrac
+        self.CompNames = CompNames
+        self.CompMolFrac = CompMolFrac
+        self.CompMasFrac = CompMasFrac
+        self.MolFlow = MolFlow
+        self.MasFlow = MasFlow
+        self.OM_data_init = ''
+        self.OM_data_eqn = ''
+        self.count = name[1]
+        self.thermoPackage ="Raoults_Law"
+        self.mode1 = "P"
+        self.mode1val = ""
+        self.mode2 = "T"
+        self.mode2val = ""
+
+        # self.ValEntList =  {"T":T," P":P," VapPhasMolFrac":vapPhasMolFrac," CompNames":CompNames," CompMolFrac[1]":CompMolFrac," CompMasFrac":CompMasFrac," MolFlow[1]":MolFlow," MasFlow[1]":MasFlow}
+
+
+        # self.OMProp = {
+        #     'Pressure': self.mode1,
+        #     'Temperature': self.mode2,
+        #     'Liquid Phase Mole Fraction': 'liqPhasMolFrac',
+        #     'Liquid Phase Mas Fraction': 'liqPhasMasFrac',
+        #     'Vapour Phase Mole Fraction': 'vapPhasMolFrac',
+        #     'Vapour Phase Mas Fraction': 'vapPhasMasFrac',
+        #     'Total Molar Flow': 'totMolFlo[1]',
+        #     'Total Mas Flow': 'totMasFlo[1]',
+        #     'Av. Molecular Weight': 'MW[1]',
+        #     'Comp Mole Fraction': ['compMolFrac[1,1]','compMolFrac[1,2]','compMolFrac[1,3]'],
+        #     'Comp Mas Fraction': ['compMasFrac[1,1]','compMasFrac[1,2]','compMasFrac[1,3]'],
+        #     'Comp Molar Flow': ['compMolFlo[1,1]','compMolFlo[1,2]','compMolFlo[1,3]'],
+        #     'Comp Mas Flow': ['compMasFlo[1,1]','compMasFlo[1,2]','compMasFlo[1,3]'],
+        #     'Molar Specific Heat': 'phasMolSpHeat[1]',
+        #     'Molar Enthalpy': 'phasMolEnth[1]',
+        #     'Molar Entropy': 'phasMolEntr[1]'
+        # }
+        self.startDict = {}
+        self.eqnDict = {}
+        
+
+        self.Prop = {
+
+            self.mode1:self.mode1val,
+            self.mode2:self.mode2val,
+            'liqPhasMolFrac':LiqPhasMolFrac,
+            'liqPhasMasFrac':LiqPhasMasFrac,
+            'vapPhasMolFrac':VapPhasMolFrac,
+            'vapPhasMasFrac':VapPhasMasFrac,
+            'totMolFlo[1]':MolFlow,
+            'totMasFlo[1]':MasFlow,
+            'MW[1]':None,
+            'MW[2]':None,
+            'MW[3]':None,
+            'phasMolSpHeat[1]':None,
+            'phasMolEnth[1]':None,
+            '[1]':None,
+            'phasMolSpHeat[2]':None,
+            'phasMolEnth[2]':None,
+            'phasMolEntr[2]':None,
+            'phasMolSpHeat[3]':None,
+            'phasMolEnth[3]':None,
+            'phasMolEntr[3]':None,
+            'totMolFlo[2]':None,
+            'totMasFlo[2]':None,
+            'totMolFlo[3]':None,
+            'totMasFlo[3]':None
+
+        }
+
+        self.Prop1 = {
+            self.mode1:self.mode1val,
+            self.mode2:self.mode2val,
+            'liqPhasMolFrac':LiqPhasMolFrac,
+            'liqPhasMasFrac':LiqPhasMasFrac,
+            'vapPhasMolFrac':VapPhasMolFrac,
+            'vapPhasMasFrac':VapPhasMasFrac,
+            'totMolFlo[1]':MolFlow,
+            'totMasFlo[1]':MasFlow,
+            'MW[1]':None,
+            'MW[2]':None,
+            'MW[3]':None,
+            'phasMolSpHeat[1]':None,
+            'phasMolEnth[1]':None,
+            'phasMolEntr[1]':None,
+            'phasMolSpHeat[2]':None,
+            'phasMolEnth[2]':None,
+            'phasMolEntr[2]':None,
+            'phasMolSpHeat[3]':None,
+            'phasMolEnth[3]':None,
+            'phasMolEntr[3]':None,
+            'totMolFlo[2]':None,
+            'totMasFlo[2]':None,
+            'totMolFlo[3]':None,
+            'totMasFlo[3]':None
+
+        }
+
+    def modesList(self):
+        return ["PT","PH","PVF","TVF","PS"]   
+    def paramgetter(self,mode):
+        dict = {}
+        if(mode=="PT"):
+            self.mode1 = 'P'
+            self.mode2 = 'T'
+            dict = {self.mode2:None,self.mode1:None,"CompMolFrac":None,"MolFlow":None,"thermoPackage":None}
+        elif(mode=="PH"):
+            self.mode1 = 'P'
+            self.mode2 = 'phasMolEnth[1]'
+            dict = {self.mode1:None,self.mode2:None,"CompMolFrac":None,"MolFlow":None,"thermoPackage":None}
+        elif(mode=="PVF"):
+            self.mode1 = 'P'
+            self.mode2 = 'vapPhasMolFrac'
+            dict = {self.mode1:None,self.mode2:None,"CompMolFrac":None,"MolFlow":None,"thermoPackage":None}
+        elif(mode=="TVF"):
+            self.mode1 = 'T'
+            self.mode2 = 'vapPhasMolFrac'
+            dict = {self.mode1:None,self.mode2:None,"CompMolFrac":None,"MolFlow":None,"thermoPackage":None}
+        elif(mode=="PS"):
+            self.mode1 = 'P'
+            self.mode2 = 'phasMolEntr[1]'
+            dict = {self.mode1:None,self.mode2:None,"CompMolFrac":None,"MolFlow":None,"thermoPackage":None}
+        
+        return dict
+    def paramsetter(self,dict):
+        self.mode1val = dict[self.mode1]
+        self.mode2val = dict[self.mode2]
+        self.MolFlow = dict['MolFlow']
+        self.CompMolFrac = dict['CompMolFrac'].split(",")
+        self.thermoPackage = dict['thermoPackage']
+        self.Prop['totMolFlo[1]'] = self.MolFlow
+        self.Prop[self.mode2] = dict[self.mode2]
+        self.Prop[self.mode1] = dict[self.mode1]
+        for i in range(len(self.CompNames)):
+            print('####### compmolfrac #########\n',self.CompMolFrac[i])
+            if self.CompMolFrac:
+                self.Prop['compMolFrac[1,'+str(i+1)+']'] = self.CompMolFrac[i]
+            else:
+                self.Prop['compMolFrac[1,'+str(i+1)+']'] = None
+
+            if self.CompMasFrac:
+                self.Prop['compMasFrac[1,'+str(i+1)+']'] = self.CompMasFrac[i]
+            else:
+                self.Prop['compMasFrac[1,'+str(i+1)+']'] = None
+            self.Prop['compMolFlo[1,'+str(i+1)+']'] = None
+            self.Prop['compMasFlo[1,'+str(i+1)+']'] = None
+        for i in range(0,len(self.CompNames)):
+            self.Prop['compMolFrac[2,'+str(i+1)+']'] = None
+            self.Prop['compMasFrac[2,'+str(i+1)+']'] = None
+            self.Prop['compMolFlo[2,'+str(i+1)+']'] = None
+            self.Prop['compMasFlo[2,'+str(i+1)+']'] = None
+            self.Prop['compMolFrac[3,'+str(i+1)+']'] = None
+            self.Prop['compMasFrac[3,'+str(i+1)+']'] = None
+            self.Prop['compMolFlo[3,'+str(i+1)+']'] = None
+            self.Prop['compMasFlo[3,'+str(i+1)+']'] = None
+            
+    def GetMinEqnValues(self):
+        compmolfraclist = []
+        for i in range(0,len(self.CompNames)):
+            print(self.Prop['compMolFrac[1,'+str(i+1)+']'])
+            compmolfraclist.append(self.Prop['compMolFrac[1,'+str(i+1)+']'])
+        print(compmolfraclist)
+        #compmolfraclist = list(self.Prop(compMolFrac[1,1)])
+        compmolfrac = json.dumps(compmolfraclist)
+        print(compmolfrac)
+        compmolfrac = compmolfrac.replace('[','{')
+        compmolfrac = compmolfrac.replace(']','}')
+        compmolfrac = compmolfrac.replace('"','')
+        '''
+        compmolfracstr = json.dumps(self.CompMolFrac)
+        compmolfracstr = compmolfracstr.replace('[','{')
+        compmolfracstr = compmolfracstr.replace(']','}')
+        compmolfracstr = compmolfracstr.replace('"','')
+        '''
+        if self.Prop[self.mode1]:
+            self.eqnDict[self.mode1] = self.Prop[self.mode1]
+        if self.Prop[self.mode2]:
+            self.eqnDict[self.mode2] = self.Prop[self.mode2]
+        if self.CompMolFrac:
+            self.eqnDict['compMolFrac[1,:]'] = compmolfrac
+        if self.MolFlow:
+            self.eqnDict['totMolFlo[1]'] = self.Prop['totMolFlo[1]']#self.MolFlow
+
+        print("##############$GetMinVEqnValuesStart$##################")
+        print("P:",self.Prop[self.mode1])
+        print("T:",self.Prop[self.mode2])
+        print("CompMolFrac",compmolfrac)
+        print("totMolFlo",self.Prop['totMolFlo[1]'])
+        print("##############$GetMinVEqnValuesEnd$##################")
+
+    def GetEquationValues(self):
+        if self.Prop[self.mode1]:
+            self.eqnDict[self.mode1] = self.Prop[self.mode1]
+        
+        if self.Prop[self.mode2]:
+            self.eqnDict[self.mode2] = self.Prop[self.mode2]
+        
+        if self.Prop['compMolFrac[1,1]']:
+            cfa = []
+            for i in range(1,len(self.CompNames)+1):
+                cfa.append(self.Prop['compMolFrac[1,'+str(i)+']'])
+            cmpMolFracstr = json.dumps(cfa)
+            cmpMolFracstr = cmpMolFracstr.replace('[','{')
+            cmpMolFracstr = cmpMolFracstr.replace(']','}')
+            cmpMolFracstr = cmpMolFracstr.replace('"','')
+            self.eqnDict['compMolFrac[1,:]'] = cmpMolFracstr
+        
+        if self.Prop['totMolFlo[1]']:
+            self.eqnDict['totMolFlo[1]'] = self.Prop['totMolFlo[1]']
+
+
+    def GetStartValues(self):
+        try:
+            if self.Prop[self.mode1]:
+                self.startDict[self.mode1] = self.Prop[self.mode1]
+            
+            if self.Prop[self.mode2]:
+                self.startDict[self.mode2] = self.Prop[self.mode2]
+            
+
+            if self.Prop['compMolFrac[2,1]'] != None:
+                compMolFracarr = []
+                for i in range(1,4):
+                    cmf = []
+                    for j in range(1,len(self.CompNames)+1):
+                        cmf.append(str(self.Prop['compMolFrac['+str(i)+','+str(j)+']']))
+                    compMolFracarr.append(cmf)
+                compMolFracstr = json.dumps(compMolFracarr)
+                compMolFracstr = compMolFracstr.replace('[','{')
+                compMolFracstr = compMolFracstr.replace(']','}')
+                compMolFracstr = compMolFracstr.replace('"','')
+                self.startDict['compMolFrac'] = compMolFracstr
+
+            if self.Prop['compMasFrac[2,1]'] != None:
+                compMasFracarr = []
+                for i in range(1,4):
+                    cmf = []
+                    for j in range(1,len(self.CompNames)+1):
+                        cmf.append(str(self.Prop['compMasFrac['+str(i)+','+str(j)+']']))
+                    compMasFracarr.append(cmf)
+                compMasFracstr = json.dumps(compMolFracarr)
+                compMasFracstr = compMasFracstr.replace('[','{')
+                compMasFracstr = compMasFracstr.replace(']','}')
+                compMasFracstr = compMasFracstr.replace('"','')
+                self.startDict['compMasFrac'] = compMasFracstr
+
+            if self.Prop['compMasFlo[2,1]'] != None:
+                compMasFloarr = []
+                for i in range(1,4):
+                    cmf = []
+                    for j in range(1,len(self.CompNames)+1):
+                        cmf.append(str(self.Prop['compMasFlo['+str(i)+','+str(j)+']']))
+                    compMasFloarr.append(cmf)
+                compMasFlostr = json.dumps(compMolFracarr)
+                compMasFlostr = compMasFlostr.replace('[','{')
+                compMasFlostr = compMasFlostr.replace(']','}')
+                compMasFlostr = compMasFlostr.replace('"','')
+                self.startDict['compMasFlo'] = compMasFlostr
+
+            if self.Prop['compMolFlo[2,1]'] != None:
+                compMolFloarr = []
+                for i in range(1,4):
+                    cmf = []
+                    for j in range(1,len(self.CompNames)+1):
+                        cmf.append(str(self.Prop['compMolFlo['+str(i)+','+str(j)+']']))
+                    compMolFloarr.append(cmf)
+                compMolFlostr = json.dumps(compMolFloarr)
+                compMolFlostr = compMolFlostr.replace('[','{')
+                compMolFlostr = compMolFlostr.replace(']','}')
+                compMolFlostr = compMolFlostr.replace('"','')
+                self.startDict['compMolFlo'] = compMolFlostr
+
+            if self.Prop['MW[2]'] != None:
+                MWArr = []
+                for i in range(1,4):
+                    MWArr.append(self.Prop['MW['+str(i)+']'])
+                MWStr = json.dumps(MWArr)
+                MWStr = MWStr.replace('[','{')
+                MWStr = MWStr.replace(']','}')
+                MWStr = MWStr.replace('"','')
+                self.startDict['MW'] = MWStr
+
+            if self.Prop['totMolFlo[2]'] != None:
+                totMolFloArr = []
+                for i in range(1,4):
+                    totMolFloArr.append(self.Prop['totMolFlo['+str(i)+']'])
+                totMolFloStr = json.dumps(totMolFloArr)
+                totMolFloStr = totMolFloStr.replace('[','{')
+                totMolFloStr = totMolFloStr.replace(']','}')
+                totMolFloStr = totMolFloStr.replace('"','')
+                self.startDict['totMolFlo'] = totMolFloStr
+
+            if self.Prop['phasMolSpHeat[2]'] != None:
+                phasMolSpHeatArr = []
+                for i in range(1,4):
+                    phasMolSpHeatArr.append(self.Prop['phasMolSpHeat['+str(i)+']'])
+                phasMolSpHeatStr = json.dumps(phasMolSpHeatArr)
+                phasMolSpHeatStr = phasMolSpHeatStr.replace('[','{')
+                phasMolSpHeatStr = phasMolSpHeatStr.replace(']','}')
+                phasMolSpHeatStr = phasMolSpHeatStr.replace('"','')
+                self.startDict['phasMolSpHeat'] = phasMolSpHeatStr
+
+            if self.Prop['phasMolEnth[2]'] != None:
+                phasMolEnthArr = []
+                for i in range(1,4):
+                    phasMolEnthArr.append(self.Prop['phasMolEnth['+str(i)+']'])
+                phasMolEnthStr = json.dumps(phasMolEnthArr)
+                phasMolEnthStr = phasMolEnthStr.replace('[','{')
+                phasMolEnthStr = phasMolEnthStr.replace(']','}')
+                phasMolEnthStr = phasMolEnthStr.replace('"','')
+                self.startDict['phasMolEnth'] = phasMolEnthStr
+
+
+            if self.Prop['phasMolEntr[2]'] != None:
+                phasMolEntrArr = []
+                for i in range(1,4):
+                    phasMolEntrArr.append(self.Prop['phasMolEntr['+str(i)+']'])
+                phasMolEntrStr = json.dumps(phasMolEntrArr)
+                phasMolEntrStr = phasMolEntrStr.replace('[','{')
+                phasMolEntrStr = phasMolEntrStr.replace(']','}')
+                phasMolEntrStr = phasMolEntrStr.replace('"','')
+                self.startDict['phasMolEntr'] = phasMolEntrStr
+
+            if self.Prop['totMasFlo[2]'] != None:
+                totMasFloArr = []
+                for i in range(1,4):
+                    totMasFloArr.append(self.Prop['totMasFlo['+str(i)+']'])
+                totMasFloStr = json.dumps(totMasFloArr)
+                totMasFloStr = totMasFloStr.replace('[','{')
+                totMasFloStr = totMasFloStr.replace(']','}')
+                totMasFloStr = totMasFloStr.replace('"','')
+                self.startDict['totMasFlo'] = totMasFloStr
+
+        except Exception as e:
+            exc_type, exc_obj, exc_tb = sys.exc_info()
+            print(exc_type,exc_tb.tb_lineno)
+            print(e)
+            print('error')
+
+        # self.OMVapProp = {
+        #     'Pressure': self.mode1,
+        #     'Temperature': self.mode2,
+        #     'Total Molar Flow': 'totMolFlo[3]',
+        #     'Total Mas Flow': 'totMasFlo[3]',
+        #     'Comp Mole Fraction': ['compMolFrac[3,1]','compMolFrac[3,2]','compMolFrac[3,3]'],
+        #     'Comp Mas Fraction': ['compMasFrac[3,1]','compMasFrac[3,2]','compMasFrac[3,3]'],
+        #     'Comp Molar Flow': ['compMolFlo[3,1]','compMolFlo[3,2]','compMolFlo[3,3]'],
+        #     'Comp Mas Flow': ['compMasFlo[3,1]','compMasFlo[3,2]','compMasFlo[3,3]'],
+        #     'Av. Molecular Weight': 'phasMolEnth[3]',
+        #     'Molar Specific Heat': 'phasMolSpHeat[3]',
+        #     'Molar Enthalpy': 'phasMolEnth[3]',
+        #     'Molar Entropy': 'phasMolEntr[3]'}
+
+
+
+        # self.VapProp = {
+        #     self.mode1:None,
+        #     self.mode2:None,
+        #     'liqPhasMolFrac':None,
+        #     'liqPhasMasFrac':None,
+        #     'vapPhasMolFrac':None,
+        #     'vapPhasMasFrac':None,
+        #     'totMolFlo[3]':None,
+        #     'totMasFlo[3]':None,
+        #     'MW[1]':None,
+        #     'compMolFrac[3,1]':None,
+        #     'compMolFrac[3,2]':None,
+        #     'compMolFrac[3,3]':None,
+        #     'compMasFrac[3,1]':None,
+        #     'compMasFrac[3,2]':None,
+        #     'compMasFrac[3,3]'None,
+        #     'compMolFlo[3,1]':None,
+        #     'compMolFlo[3,2]':None,
+        #     'compMolFlo[3,3]':None,
+        #     'compMasFlo[3,1]':None,
+        #     'compMasFlo[3,2]':None,
+        #     'compMasFlo[3,3]':None,
+        #     'phasMolSpHeat[3]':None,
+        #     'phasMolEnth[3]':None,
+        #     'phasMolEntr[3]':None
+        #     }
+
+
+        # self.OMLiqProp = {
+        #     'Pressure': self.mode1,
+        #     'Temperature': self.mode2,
+        #     'Total Molar Flow': 'totMolFlo[2]',
+        #     'Total Mas Flow': 'totMasFlo[2]',
+        #     'Comp Mole Fraction': ['compMolFrac[2,1]','compMolFrac[2,2]','compMolFrac[2,3]'],
+        #     'Comp Mas Fraction': ['compMasFrac[2,1]','compMasFrac[2,2]','compMasFrac[2,3]'],
+        #     'Comp Molar Flow': ['compMolFlo[2,1]','compMolFlo[2,2]','compMolFlo[2,3]'],
+        #     'Comp Mas Flow': ['compMasFlo[2,1]','compMasFlo[2,2]','compMasFlo[2,3]'],
+        #     'Av. Molecular Weight': 'MW[2]',
+        #     'Molar Specific Heat': 'phasMolSpHeat[2]',
+        #     'Molar Enthalpy': 'phasMolEnth[2]',
+        #     'Molar Entropy': 'phasMolEntr[2]'}
+
+
+        # self.LiqProp = {
+        #     self.mode1:P,
+        #     self.mode2:None,
+        #     'liqPhasMolFrac':None,
+        #     'liqPhasMasFrac':None,
+        #     'vapPhasMolFrac':None,
+        #     'vapPhasMasFrac':None,
+        #     'totMolFlo[2]':None,
+        #     'totMasFlo[2]':None,
+        #     'MW[1]':None,
+        #     'compMolFrac[2,1]':None,
+        #     'compMolFrac[2,2]':None,
+        #     'compMolFrac[2,3]':None,
+        #     'compMasFrac[2,1]':None,
+        #     'compMasFrac[2,2]':None,
+        #     'compMasFrac[2,3]'None,
+        #     'compMolFlo[2,1]':None,
+        #     'compMolFlo[2,2]':None,
+        #     'compMolFlo[2,3]':None,
+        #     'compMasFlo[2,1]':None,
+        #     'compMasFlo[2,2]':None,
+        #     'compMasFlo[2,3]':None,
+        #     'phasMolSpHeat[2]':None,
+        #     'phasMolEnth[2]':None,
+        #     'phasMolEntr[2]':None
+        #     }
+
+    def OM_Flowsheet_Init(self,addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + ("model ms"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Streams.Material_Stream;\n" )
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Files.Thermodynamic_Packages."+self.thermoPackage+";\n")
+        self.OM_data_init = self.OM_data_init + ("end ms"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.GetStartValues()
+
+        #self.OM_data_init = "Simulator.Streams.Mat_Stm_RL " + self.name +"(NOC = " + str(comp_count)
+        self.OM_data_init = self.OM_data_init + "ms"+str(self.count) +" " + self.name +"(NOC = " + str(comp_count)
+        self.OM_data_init = self.OM_data_init + ",comp = {"
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'","")
+        self.OM_data_init = self.OM_data_init + comp + "},"
+        #for key, value in self.startDict.items():
+        #    self.OM_data_init = self.OM_data_init + key + '(start = ' + str(value) + '),'
+        self.OM_data_init = self.OM_data_init[:-1]
+        self.OM_data_init = self.OM_data_init + ');\n'        
+        return self.OM_data_init
+
+
+    def OM_Flowsheet_Eqn(self,addedcomp,method):
+        self.OM_data_eqn = ''
+        self.comp_count = len(addedcomp)
+        if method == 'Eqn':
+            self.eqnDict = {}
+            self.GetMinEqnValues()
+        if method == 'SM':
+            self.eqnDict = {}
+            self.GetMinEqnValues()
+            #self.GetEquationValues()
+        #self.GetEquationValues()
+
+        for key,value in self.eqnDict.items():
+            self.OM_data_eqn = self.OM_data_eqn + self.name + '.'+ key + ' = ' + str(value) + ';\n'
+        return self.OM_data_eqn
+
+      
+        # if self.P:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + '.P=' + str(self.P) + ';\n')
+        # if self.T:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + '.T=' + str(self.T) + ';\n')
+        # if self.VapPhasMolFrac:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + '.vapPhasMolFrac=' + str(self.VapPhasMolFrac) + ';\n')
+        
+
+        # if self.CompMolFrac != []:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + ".compMolFrac[1,:] = {")
+        #     mf = str(self.CompMolFrac).strip('[').strip(']')
+        #     self.OM_data_eqn = self.OM_data_eqn + mf + ('};\n')
+        # if self.CompMasFrac != []:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + ".compMasFrac[1,:] = {")
+        #     Mf = str(self.CompMasFrac).strip('[').strip(']')
+        #     self.OM_data_eqn = self.OM_data_eqn + Mf + ('};\n')
+        
+        # if self.MolFlow:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + ".totMolFlo[1] = " + str(self.MolFlow) + ";\n")
+        # if self.MasFlow:
+        #     self.OM_data_eqn = self.OM_data_eqn + (self.name + ".totMasFlo[1] = " + str(self.MasFlow) + ";\n")
+
+        # return self.OM_data_eqn
\ No newline at end of file
diff --git a/OMChem/Mixer.py b/OMChem/Mixer.py
new file mode 100644
index 0000000..9419de1
--- /dev/null
+++ b/OMChem/Mixer.py
@@ -0,0 +1,49 @@
+class Mixer():
+    def __init__(self,name='mixer',NOI=5,Pcal = 'Inlet_Average'):
+        self.NOI = NOI
+        self.Pcal = Pcal
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = []
+        self.OutputStms = None
+        self.type = 'Mixer'
+
+    def modesList(self):
+        return []   
+
+    def paramgetter(self,mode=None):
+        dict = {}
+        return dict
+    def paramsetter(self,dict):
+        self.NOI = dict["NOI"]
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Mixer " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + ("outPress = \""+self.Pcal+"\",NI=" + str(self.NOI) + ");\n")
+        return self.OM_data_init
+
+    def connect(self,InputStms = [],OutputStms = None):
+        self.NOI=len(InputStms)
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        comp_count = len(addedcomp)
+        strcount = 1
+        for strm in self.InputStms:
+            self.OM_data_eqn = self.OM_data_eqn + (
+            'connect(' + strm.name + '.outlet,' + self.name + '.inlet[' + str(strcount) + ']);\n')
+            strcount += 1
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        return self.OM_data_eqn
+
diff --git a/OMChem/Pump.py b/OMChem/Pump.py
new file mode 100644
index 0000000..04c8425
--- /dev/null
+++ b/OMChem/Pump.py
@@ -0,0 +1,58 @@
+from OMChem.EngStm import EngStm
+class Pump():
+    def __init__(self,name='Pump',eff = None):
+        self.eff = eff
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        #self.heatAdd=heatAdd
+        #self.outT = outT
+        self.OutputStms = None
+        self.EngStms = EngStm(name='EngStm'+name)
+        self.type = 'Pump'
+        self.mode = None
+        self.modeVal = None
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["pressInc","outP","reqPow","enFlo"]
+
+    def paramgetter(self,mode="pressInc"):
+        self.mode = mode
+        dict = {"eff":None,self.mode:None}
+        return dict
+        
+    def paramsetter(self,dict):
+        
+        self.eff = dict['eff']
+        self.modeVal = dict[self.mode]
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Centrifugal_Pump " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + 'eff = ' + str(self.eff) + ');\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,' + self.name + '.energy);\n')
+
+        if(self.mode =="enFlo"):
+            self.OM_data_eqn = self.OM_data_eqn + (self.EngStms.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        else:    
+            self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        return self.OM_data_eqn
diff --git a/OMChem/ShortcutColumn.py b/OMChem/ShortcutColumn.py
new file mode 100644
index 0000000..13cffea
--- /dev/null
+++ b/OMChem/ShortcutColumn.py
@@ -0,0 +1,76 @@
+from OMChem.EngStm import EngStm
+class ShortcutColumn():
+    def __init__(self,name=("ShortcutCol",1),condP = None, rebP = None, LKey = None, HKey = None):
+        self.condP = condP
+        self.rebP = rebP
+        self.LKey = LKey
+        self.HKey = HKey
+        self.LKeyMolFrac = None
+        self.HKeyMolFrac = None
+        self.name = name[0]
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.EngStm1 = EngStm(name='EngStm1'+self.name)
+        self.EngStm2 = EngStm(name='EngStm2'+self.name)
+        self.count = name[1]
+        self.condType=''
+        self.actR = None
+        self.thermoPackage='Raoults_Law'
+        self.type = 'ShortCol'
+
+    def modesList(self):
+        return []
+
+    def paramgetter(self,mode=None):
+        dict = { "HKey" : None,"LKey" :None,"HKeyMolFrac":None,"LKeyMolFrac":None,"condType":None,"thermoPackage":None,"condP":None,"rebP":None,"actR":None}
+        return dict
+        
+    def paramsetter(self,dict):
+        self.HKey = dict["HKey"]
+        self.LKey = dict["LKey"]
+        self.HKeyMolFrac = dict["HKeyMolFrac"]
+        self.LKeyMolFrac=dict["LKeyMolFrac"]
+        self.condP=dict["condP"]
+        self.rebP=dict["rebP"]
+        self.actR=dict["actR"]
+        self.condType=dict["condType"]
+        self.thermoPackage=dict["thermoPackage"]
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + ("model sc"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Unit_Operations.Shortcut_Column;\n" )
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Files.Thermodynamic_Packages."+self.thermoPackage+";\n")
+        self.OM_data_init = self.OM_data_init + ("end sc"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + "sc"+str(self.count)+ " " + self.name + "(NOC = " + str(comp_count)
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + 'condType = ' + "\""+self.condType+"\""+','
+        self.OM_data_init = self.OM_data_init + 'HKey = ' + str(self.HKey) +','
+        self.OM_data_init = self.OM_data_init + 'LKey = ' + str(self.LKey)  + ');\n'
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStm1.name+';\n'
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStm2.name+';\n'
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+       
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.reboiler_duty,' +self.EngStm1.name +'.outlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStm2.name+'.inlet,' + self.name + '.condenser_duty);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.distillate,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.bottoms,' + self.OutputStms[1].name + '.inlet);\n')
+        
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' + self.name + '.feed);\n')
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.rebP = ' + self.rebP + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.condP = ' + self.condP + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.mixMolFrac[2,'+self.name+'.LKey]='+self.LKeyMolFrac+ ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.mixMolFrac[3,'+self.name+'.HKey]='+self.HKeyMolFrac+ ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.actR=' + self.actR + ';\n'
+        return self.OM_data_eqn
\ No newline at end of file
diff --git a/OMChem/Splitter.py b/OMChem/Splitter.py
new file mode 100644
index 0000000..a055851
--- /dev/null
+++ b/OMChem/Splitter.py
@@ -0,0 +1,52 @@
+
+import json
+class Splitter():
+    def __init__(self,name='splitter',NOO=5,calcType = 'Molar_Flow',specval = [50,50]):
+        self.NOO = NOO
+        self.calcType = calcType
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = []
+        self.type = 'Splitter'
+        self.specval = json.dumps(specval).replace('[','{').replace(']','}')
+        
+    def modesList(self):
+        return []   
+    def paramgetter(self,mode=None):
+        dict = {"NOO":None}
+        return dict
+    def paramsetter(self,dict):
+        self.NOI = dict["NOO"]
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Splitter " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")
+        self.OM_data_init = self.OM_data_init + ("calcType = \""+self.calcType+"\",NO=" + str(self.NOO) + ");\n")
+        return self.OM_data_init
+
+    def connect(self,InputStms = None,OutputStms = []):
+        self.NOO=len(OutputStms)
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        comp_count = len(addedcomp)
+        strcount = 1
+        print("Output#########",self.OutputStms)
+        for strm in self.OutputStms:
+            self.OM_data_eqn = self.OM_data_eqn + (
+            'connect(' + strm.name + '.inlet,' + self.name + '.outlet[' + str(strcount) + ']);\n')
+            strcount += 1
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.inlet,' + self.InputStms[0].name + '.outlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + self.name +'.' +'specVal =' + self.specval +';\n'
+        return self.OM_data_eqn
diff --git a/OMChem/Valve.py b/OMChem/Valve.py
new file mode 100644
index 0000000..f8f61b6
--- /dev/null
+++ b/OMChem/Valve.py
@@ -0,0 +1,52 @@
+class Valve():
+    def __init__(self,name='valve'):
+        #self.PressDrop = PressureDrop
+        self.mode = None
+        self.modeVal = None
+        self.name = name
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.type = 'Valve'
+
+        self.Prop = {
+                'pressDrop':None,
+                'outP':None
+            }
+
+    def modesList(self):
+        return ["pressDrop","outP"]
+
+    def paramgetter(self,mode="pressDrop"):
+        self.mode = mode
+        dict = {self.mode:None}
+        return dict
+
+    def paramsetter(self,dict):
+
+        self.modeVal = dict[self.mode]      
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "Simulator.Unit_Operations.Valve " + self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("});\n")
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        print("asdfvfdasdsqdfdedfdfv12345678987654321234567898765")
+        self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+        return self.OM_data_eqn
\ No newline at end of file
diff --git a/OMChem/__pycache__/CompSep.cpython-36.pyc b/OMChem/__pycache__/CompSep.cpython-36.pyc
new file mode 100644
index 0000000..dc4410b
--- /dev/null
+++ b/OMChem/__pycache__/CompSep.cpython-36.pyc
diff --git a/OMChem/__pycache__/Cooler.cpython-36.pyc b/OMChem/__pycache__/Cooler.cpython-36.pyc
new file mode 100644
index 0000000..be8d9fe
--- /dev/null
+++ b/OMChem/__pycache__/Cooler.cpython-36.pyc
diff --git a/OMChem/__pycache__/DistCol.cpython-36.pyc b/OMChem/__pycache__/DistCol.cpython-36.pyc
new file mode 100644
index 0000000..518410e
--- /dev/null
+++ b/OMChem/__pycache__/DistCol.cpython-36.pyc
diff --git a/OMChem/__pycache__/EngStm.cpython-36.pyc b/OMChem/__pycache__/EngStm.cpython-36.pyc
new file mode 100644
index 0000000..8799e46
--- /dev/null
+++ b/OMChem/__pycache__/EngStm.cpython-36.pyc
diff --git a/OMChem/__pycache__/Flash.cpython-36.pyc b/OMChem/__pycache__/Flash.cpython-36.pyc
new file mode 100644
index 0000000..3c55d7e
--- /dev/null
+++ b/OMChem/__pycache__/Flash.cpython-36.pyc
diff --git a/OMChem/__pycache__/Flowsheet.cpython-36.pyc b/OMChem/__pycache__/Flowsheet.cpython-36.pyc
new file mode 100644
index 0000000..dd8f589
--- /dev/null
+++ b/OMChem/__pycache__/Flowsheet.cpython-36.pyc
diff --git a/OMChem/__pycache__/Heater.cpython-36.pyc b/OMChem/__pycache__/Heater.cpython-36.pyc
new file mode 100644
index 0000000..1139a24
--- /dev/null
+++ b/OMChem/__pycache__/Heater.cpython-36.pyc
diff --git a/OMChem/__pycache__/MatStm.cpython-36.pyc b/OMChem/__pycache__/MatStm.cpython-36.pyc
new file mode 100644
index 0000000..9b5b187
--- /dev/null
+++ b/OMChem/__pycache__/MatStm.cpython-36.pyc
diff --git a/OMChem/__pycache__/Mixer.cpython-36.pyc b/OMChem/__pycache__/Mixer.cpython-36.pyc
new file mode 100644
index 0000000..c75307b
--- /dev/null
+++ b/OMChem/__pycache__/Mixer.cpython-36.pyc
diff --git a/OMChem/__pycache__/Pump.cpython-36.pyc b/OMChem/__pycache__/Pump.cpython-36.pyc
new file mode 100644
index 0000000..c351aba
--- /dev/null
+++ b/OMChem/__pycache__/Pump.cpython-36.pyc
diff --git a/OMChem/__pycache__/ShortcutColumn.cpython-36.pyc b/OMChem/__pycache__/ShortcutColumn.cpython-36.pyc
new file mode 100644
index 0000000..1ea4727
--- /dev/null
+++ b/OMChem/__pycache__/ShortcutColumn.cpython-36.pyc
diff --git a/OMChem/__pycache__/Splitter.cpython-36.pyc b/OMChem/__pycache__/Splitter.cpython-36.pyc
new file mode 100644
index 0000000..2830093
--- /dev/null
+++ b/OMChem/__pycache__/Splitter.cpython-36.pyc
diff --git a/OMChem/__pycache__/Valve.cpython-36.pyc b/OMChem/__pycache__/Valve.cpython-36.pyc
new file mode 100644
index 0000000..aba6ad1
--- /dev/null
+++ b/OMChem/__pycache__/Valve.cpython-36.pyc
diff --git a/OMChem/__pycache__/adiabatic_comp.cpython-36.pyc b/OMChem/__pycache__/adiabatic_comp.cpython-36.pyc
new file mode 100644
index 0000000..c5e8b65
--- /dev/null
+++ b/OMChem/__pycache__/adiabatic_comp.cpython-36.pyc
diff --git a/OMChem/__pycache__/adiabatic_exp.cpython-36.pyc b/OMChem/__pycache__/adiabatic_exp.cpython-36.pyc
new file mode 100644
index 0000000..1138bdc
--- /dev/null
+++ b/OMChem/__pycache__/adiabatic_exp.cpython-36.pyc
diff --git a/OMChem/adiabatic_comp.py b/OMChem/adiabatic_comp.py
new file mode 100644
index 0000000..b8849fd
--- /dev/null
+++ b/OMChem/adiabatic_comp.py
@@ -0,0 +1,59 @@
+from OMChem.EngStm import EngStm
+class AdiaComp():
+    def __init__(self,name=('AdiaComp',1), eff = None):
+        self.eff = eff
+        self.name = name[0]
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.EngStms = EngStm(name='EngStm'+self.name)
+        self.count = name[1]
+        self.type = 'AdiaComp'
+        self.thermoPackage ="Raoults_Law"
+        self.mode = None
+        self.modeVal = None
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["pressInc","outP","reqPow"]
+
+    def paramgetter(self,mode="pressInc"):
+        self.mode = mode
+        dict = {"eff":None,self.mode:None,"thermoPackage":None}
+        return dict
+        
+    def paramsetter(self,dict):
+        self.eff = dict['eff']
+        self.modeVal = dict[self.mode]
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + ("model adiaComp"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Unit_Operations.Adiabatic_Compressor;\n" )
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Files.Thermodynamic_Packages."+self.thermoPackage+";\n")
+        self.OM_data_init = self.OM_data_init + ("end adiaComp"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "adiaComp"+str(self.count)+" "+ self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")+("eff="+self.eff+");\n")
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,' + self.name + '.energy);\n')
+  
+        self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+
+        return self.OM_data_eqn
+        
diff --git a/OMChem/adiabatic_exp.py b/OMChem/adiabatic_exp.py
new file mode 100644
index 0000000..102596d
--- /dev/null
+++ b/OMChem/adiabatic_exp.py
@@ -0,0 +1,59 @@
+from OMChem.EngStm import EngStm
+class AdiaExp():
+    def __init__(self,name=('AdiaExp',1), eff = None):
+        self.eff = eff
+        self.name = name[0]
+        self.OM_data_eqn = ''
+        self.OM_data_init = ''
+        self.InputStms = None
+        self.OutputStms = None
+        self.EngStms = EngStm(name='EngStm'+self.name)
+        self.count = name[1]
+        self.type = 'AdiaExp'
+        self.thermoPackage ="Raoults_Law"
+        self.mode = None
+        self.modeVal = None
+
+    def connect(self,InputStms = None,OutputStms = None):
+        self.InputStms = InputStms
+        self.OutputStms = OutputStms
+
+    def modesList(self):
+        return ["pressDrop","outP","genPow"]
+
+    def paramgetter(self,mode="pressDrop"):
+        self.mode = mode
+        dict = {"eff":None,self.mode:None,"thermoPackage":None}
+        return dict
+        
+    def paramsetter(self,dict):
+        self.eff = dict['eff']
+        self.modeVal = dict[self.mode]
+
+    def OM_Flowsheet_Init(self, addedcomp):
+        self.OM_data_init = ''
+        self.OM_data_init = self.OM_data_init + 'Simulator.Streams.Energy_Stream '+self.EngStms.name+';\n'
+        self.OM_data_init = self.OM_data_init + ("model adiaComp"+str(self.count)+"\n")
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Unit_Operations.Adiabatic_Expander;\n" )
+        self.OM_data_init = self.OM_data_init + ("extends Simulator.Files.Thermodynamic_Packages."+self.thermoPackage+";\n")
+        self.OM_data_init = self.OM_data_init + ("end adiaComp"+str(self.count)+";\n")
+        comp_count = len(addedcomp)
+        self.OM_data_init = self.OM_data_init + (
+        "adiaComp"+str(self.count)+" "+ self.name + "(NOC = " + str(comp_count))
+        self.OM_data_init = self.OM_data_init + (",comp = {")
+        comp = str(addedcomp).strip('[').strip(']')
+        comp = comp.replace("'", "")
+        self.OM_data_init = self.OM_data_init + comp + ("},")+("eff="+self.eff+");\n")
+        return self.OM_data_init
+
+    def OM_Flowsheet_Eqn(self, addedcomp):
+        self.OM_data_eqn = ''
+        # self.OM_data_eqn = self.name + '.pressDrop = ' + str(self.PressDrop) + ';\n'
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.InputStms[0].name + '.outlet,' +  self.name + '.inlet' + ');\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.name + '.outlet,' + self.OutputStms[0].name + '.inlet);\n')
+        self.OM_data_eqn = self.OM_data_eqn + ('connect(' + self.EngStms.name + '.outlet,' + self.name + '.energy);\n')
+  
+        self.OM_data_eqn = self.OM_data_eqn + (self.name+'.'+self.mode+'='+ self.modeVal + ';\n')
+
+        return self.OM_data_eqn
+        
diff --git a/OMChem/setup.py b/OMChem/setup.py
new file mode 100644
index 0000000..765aa04
--- /dev/null
+++ b/OMChem/setup.py
@@ -0,0 +1,54 @@
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+from subprocess import call
+import sys
+import os
+# Python 3.3 offers shutil.which()
+from distutils import spawn
+
+def warningOrError(errorOnFailure, msg):
+  if errorOnFailure:
+    raise Exception(msg)
+  else:
+    print(msg)
+
+def generateIDL():
+  errorOnFailure = not os.path.exists(os.path.join(os.path.dirname(__file__), 'OMPythonIDL', '__init__.py'))
+  try:
+    omhome = os.path.split(os.path.split(os.path.realpath(spawn.find_executable("omc")))[0])[0]
+  except:
+    omhome = None
+  omhome = omhome or os.environ.get('OPENMODELICAHOME')
+
+  if omhome is None:
+    warningOrError(errorOnFailure, "Failed to find OPENMODELICAHOME (searched for environment variable as well as the omc executable)")
+    return
+  idl = os.path.join(omhome,"share","omc","omc_communication.idl")
+  if not os.path.exists(idl):
+    warningOrError(errorOnFailure, "Path not found: %s" % idl)
+    return
+
+  if 0<>call(["omniidl","-bpython","-Wbglobal=_OMCIDL","-Wbpackage=OMPythonIDL",idl]):
+    warningOrError(errorOnFailure, "omniidl command failed")
+    return
+  print("Generated OMPythonIDL files")
+generateIDL()
+
+setup(name='OMPython',
+      version='2.0.7',
+      description='OpenModelica-Python API Interface',
+      author='Anand Kalaiarasi Ganeson',
+      author_email='ganan642@student.liu.se',
+      maintainer='Adeel Asghar',
+      maintainer_email='adeel.asghar@liu.se',
+      license="BSD, OSMC-PL 1.2, GPL (user's choice)",
+      url='http://openmodelica.org/',
+      packages=['OMPython', 'OMPython.OMParser', 'OMPythonIDL', 'OMPythonIDL._OMCIDL', 'OMPythonIDL._OMCIDL__POA'],
+      install_requires=[
+        # 'omniORB', # Required, but not part of pypi
+        'pyparsing'
+      ]
+)