diff options
author | pravindalve | 2019-10-30 19:34:21 +0530 |
---|---|---|
committer | pravindalve | 2019-10-30 19:34:21 +0530 |
commit | d77a48ced21b2c5f8293148379f061897c50d4f4 (patch) | |
tree | 08aab75b2fc4979dfb97a7b97429da916e8c2936 /OMChem | |
download | Chemical-Simulator-GUI-d77a48ced21b2c5f8293148379f061897c50d4f4.tar.gz Chemical-Simulator-GUI-d77a48ced21b2c5f8293148379f061897c50d4f4.tar.bz2 Chemical-Simulator-GUI-d77a48ced21b2c5f8293148379f061897c50d4f4.zip |
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
Diffstat (limited to 'OMChem')
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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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 Binary files differnew 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' + ] +) |