def resetCase(self):
[self.timedir,self.fields,self.currtime] = currentFields(self.currentFolder,nproc=self.window().nproc)
w = reset()
result = w.exec_()
if result:
self.window().nproc = 1
command = 'pyFoamClearCase.py %s %s'%(w.getParams(), self.currentFolder)
os.system(command)
#if w.deleteSnapshots():
# command = 'rm -rf %s/postProcessing/snapshots'%self.currentFolder
# os.system(command)
if w.resetFigures():
self.window().resetFigures(w.deletePostpro(),True)
filename = '%s/system/controlDict'%self.currentFolder
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['startFrom'] = 'startTime'
parsedData['startTime'] = '0'
parsedData.writeFile()
self.window().typeFile = {}
self.window().pending_files = []
self.window().pending_dirs = []
self.window().updateLogFiles()
self.type_serial.setChecked(True)
self.type_parallel.setChecked(False)
self.changeType()
self.window().save_config()
def setData(self, data):
#self.spinBox.setValue(data['nsteps']) if 'nsteps' in data.keys() else None
#self.nop.setValue(data['nop']) if 'nop' in data.keys() else None
self.name.setText(data['name']) if 'name' in data.keys() else None
#self.comboBox.setCurrentText(data['field']) if 'field' in data.keys() else None
#self.comboBox.setCurrentText(data['autorefreshing']) if 'autorefreshing' in data.keys() else None
self.p1_x.setText(data['p1x']) if 'p1x' in data.keys() else None
self.p1_y.setText(data['p1y']) if 'p1y' in data.keys() else None
self.p1_z.setText(data['p1z']) if 'p1z' in data.keys() else None
self.p2_x.setText(data['p2x']) if 'p2x' in data.keys() else None
self.p2_y.setText(data['p2y']) if 'p2y' in data.keys() else None
self.p2_z.setText(data['p2z']) if 'p2z' in data.keys() else None
filename = '%s/system/controlDict' % (self.currentFolder)
parsedData = ParsedParameterFile(filename, createZipped=False)
if 'functions' in parsedData.getValueDict().keys():
if data['name'] in parsedData['functions'].keys():
dicc = parsedData['functions'][data['name']]
if dicc['type'] == 'sets':
self.name.setText(data['name'])
self.spinBox.setValue(dicc['outputInterval'])
return data
def aplicar(self):
filename = '%s/system/controlDict'%self.currentFolder
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['startFrom'] = self.cb_start_from_iinv[self.cb_start_from.currentIndex()]
parsedData['startTime'] = str(self.start_from.text())
parsedData['endTime'] = str(self.end_time.text())
parsedData['deltaT'] = str(self.delta_time.text())
if self.adjustable.isChecked():
parsedData['adjustTimeStep'] = 'yes'
else:
parsedData['adjustTimeStep'] = 'no'
parsedData['maxCo'] = str(self.max_cfl.text())
parsedData['maxAlphaCo'] = str(self.max_cfl_alpha.text())
parsedData['maxDeltaT'] = str(self.max_deltat.text())
parsedData['writeControl'] = self.cb_write_control_iinv[self.cb_write_control.currentIndex()]
parsedData['writeInterval'] = str(self.write_control.text())
parsedData['purgeWrite'] = str(self.purge.value())
parsedData['writePrecision'] = str(self.precision.value())
parsedData['writeFormat'] = self.format_iinv[self.format.currentIndex()]
parsedData['timePrecision'] = str(self.precision_time.value())
parsedData['writeCompression'] = self.compression_iinv[self.compression.currentIndex()]
parsedData['stopAt'] = 'endTime'
parsedData.writeFile()
self.pushButton.setEnabled(False)
self.window().updateLogFiles()
return
def aplicar(self):
filename = '%s/system/controlDict' % self.currentFolder
parsedData = ParsedParameterFile(filename, createZipped=False)
parsedData['startFrom'] = self.cb_start_from_iinv[
self.cb_start_from.currentIndex()]
parsedData['startTime'] = str(self.start_from.text())
parsedData['endTime'] = str(self.end_time.text())
parsedData['deltaT'] = str(self.delta_time.text())
if self.adjustable.isChecked():
parsedData['adjustTimeStep'] = 'yes'
else:
parsedData['adjustTimeStep'] = 'no'
parsedData['maxCo'] = str(self.max_cfl.text())
parsedData['maxAlphaCo'] = str(self.max_cfl_alpha.text())
parsedData['maxDeltaT'] = str(self.max_deltat.text())
parsedData['writeControl'] = self.cb_write_control_iinv[
self.cb_write_control.currentIndex()]
parsedData['writeInterval'] = str(self.write_control.text())
parsedData['purgeWrite'] = str(self.purge.value())
parsedData['writePrecision'] = str(self.precision.value())
parsedData['writeFormat'] = self.format_iinv[
self.format.currentIndex()]
parsedData['timePrecision'] = str(self.precision_time.value())
parsedData['writeCompression'] = self.compression_iinv[
self.compression.currentIndex()]
parsedData['stopAt'] = 'endTime'
parsedData.writeFile()
self.pushButton.setEnabled(False)
self.window().updateLogFiles()
return
def setDict(dict_file, key, value):
"""all parameters are string type, accept, None or empty string
dict_file: file must exist, checked by caller
key: create the key if not existent
value: None or empty string will delet such key
"""
if isinstance(key, string_types) and key.find('/')>=0:
group = [k for k in key.split('/') if k]
elif isinstance(key, list) or isinstance(key, tuple):
group = [s for s in key if isinstance(s, string_types)]
else:
print("Warning: input key is not string or sequence type, so do nothing but return".format(key))
return
f = ParsedParameterFile(dict_file)
if len(group) == 3:
d = f[group[0]][group[1]] # at most 3 levels, assuming it will auto create not existent key
elif len(group) == 2:
d = f[group[0]]
else:
d = f
k = group[-1]
if value: #
d[k] = value
elif key in d:
del d[k] #if None, or empty string is specified, delete this key
else:
print('Warning: check parameters for set_dict() key={} value={}'.format(key, value))
f.writeFile()
def saveBCs(self):
ipatch = str(self.listWidget.currentItem().text())
for itab in range(self.tabWidget.count()):
ifield = str(self.tabWidget.tabText(itab))
itype = str(self.tabWidget.widget(itab).findChildren(QtGui.QComboBox)[0].currentText())
layout = self.tabWidget.widget(itab).findChildren(QtGui.QVBoxLayout)[0]
filename = '%s/%s'%(self.timedir,ifield)
parsedData = ParsedParameterFile(filename,listLengthUnparsed=20,createZipped=False)
parsedData['boundaryField'][ipatch] = {}
parsedData['boundaryField'][ipatch]['type'] = itype
#debo tomar los valores extras, si los tiene
extraInfo = extras[ifield][itype]
L = range(layout.count())
L = L[1:-1]
iExtra = 0
print ipatch
for l in L:
layout2 = layout.itemAt(l).layout()
if layout2:
if layout2.itemAt(1).widget().currentText() != 'table':
if layout2.count()==3:
parsedData['boundaryField'][ipatch][extraInfo[iExtra*4]] = '%s %s' %(layout2.itemAt(1).widget().currentText(),layout2.itemAt(2).widget().text())
else:
parsedData['boundaryField'][ipatch][extraInfo[iExtra*4]] = '%s (%s %s %s)' %(layout2.itemAt(1).widget().currentText(),layout2.itemAt(2).widget().text(),layout2.itemAt(3).widget().text(),layout2.itemAt(4).widget().text())
else:
#determinar que hacer si quiero cargar una table!!!
#('table', [[0, 0.0], [1e6-0.01, 0.0], [1e6, 1.0], [1e6, 1.0]])
tabla = self.getTabla(itab)
parsedData['boundaryField'][ipatch][extraInfo[iExtra*4]] = ('table',tabla)
iExtra = iExtra+1
parsedData.writeFile()
self.pushButton.setEnabled(False)
return
def updateFieldFiles(self):
#tengo que releer cada uno de los campos en el directorio actual,
#pisar los boundaries por los que aparece en constant/polyMesh/boundary
#imponerles alguna CB por defecto dependiendo del tipo de patch
boundaries = BoundaryDict(self.currentFolder)
#veo los campos que tengo en el directorio inicial
[timedir,fields,currtime] = currentFields(self.currentFolder, False)
for ifield in fields:
filename = '%s/%s'%(timedir,ifield)
fieldData = ParsedParameterFile(filename,createZipped=False)
fieldData['boundaryField'] = {}
for ipatch in boundaries.getValueDict():
if ipatch not in fieldData['boundaryField']:
if boundaries[ipatch]['nFaces']==0:
continue
patchDict={}
if ifield in unknowns:
patchDict['type'] = 'zeroGradient'
else:
patchDict['type'] = 'calculated'
fieldData['boundaryField'][ipatch] = patchDict
fieldData.writeFile()
return
def loadCaseData(self):
filename = '%s/system/controlDict' % self.currentFolder
backupFile(filename)
self.parsedData = ParsedParameterFile(filename, createZipped=False)
self.tracersData = []
if 'functions' in self.parsedData.getValueDict().keys():
for key in self.parsedData['functions'].keys():
if self.parsedData['functions'][key][
'type'] == 'scalarTransport':
tracer = {}
tracer['name'] = key
tracer['patchName'] = self.parsedData['functions'][key][
'patchName']
tracer['startTime'] = self.parsedData['functions'][key][
'fvOptions']['S']['timeStart']
#TODO: cargar aca
if tracer['patchName'] == 'box':
tracer['p0'] = self.parsedData['functions'][key][
'fvOptions']['S']['p0']
tracer['p1'] = self.parsedData['functions'][key][
'fvOptions']['S']['p1']
self.tracersData.append(tracer)
if self.patches == []:
boundaries = BoundaryDict(str(self.currentFolder))
self.patches = boundaries.patches()
for ipatch in self.patches:
if boundaries[ipatch]['type'] == 'empty':
self.emptys.append(ipatch)
self.pushButton_3.setEnabled(True)
def updateFieldFiles(self):
#tengo que releer cada uno de los campos en el directorio actual,
#pisar los boundaries por los que aparece en constant/polyMesh/boundary
#imponerles alguna CB por defecto dependiendo del tipo de patch
boundaries = BoundaryDict(self.currentFolder)
#veo los campos que tengo en el directorio inicial
[timedir, fields, currtime] = currentFields(self.currentFolder, False)
for ifield in fields:
filename = '%s/%s' % (timedir, ifield)
fieldData = ParsedParameterFile(filename, createZipped=False)
fieldData['boundaryField'] = {}
for ipatch in boundaries.getValueDict():
if ipatch not in fieldData['boundaryField']:
if boundaries[ipatch]['nFaces'] == 0:
continue
patchDict = {}
if ifield in unknowns:
patchDict['type'] = 'zeroGradient'
else:
patchDict['type'] = 'calculated'
fieldData['boundaryField'][ipatch] = patchDict
fieldData.writeFile()
return
def changePatchType(self,item):
texto = str(item.text())
w = bcPatch(self.boundaries[texto]['type'])
result = w.exec_()
if result:
patchType = w.getPatchType()
self.boundaries[texto]['type'] = patchType
self.boundaries.writeFile()
for ifield in self.fields:
filename = '%s/%s'%(self.timedir,ifield)
fieldData = ParsedParameterFile(filename,listLengthUnparsed=20,createZipped=False)
newDict = {}
if patchType == 'empty':
newDict['type'] = 'empty'
else:
if ifield in unknowns:
newDict['type'] = 'zeroGradient'
else:
newDict['type'] = 'calculated'
fieldData['boundaryField'][texto] = newDict
fieldData.writeFile()
self.loadData()
def exportData(self):
if self.nproc > 1:
w = QtGui.QMessageBox(
QtGui.QMessageBox.Information, "Error", "Data only can be exported in reconstructed cases"
)
w.exec_()
return
tt = ""
if self.time_4.currentText() == "Latest Time":
tt = "-latestTime"
opt = str(self.comboBox.currentText())
filename = "%s/export.log" % self.currentFolder
self.window().newLogTab("Export", filename)
if opt == "VTK":
action = "foamToVTK -case %s %s > %s &" % (self.currentFolder, tt, filename)
elif opt == "Fluent":
action = "foamMeshToFluent -case %s &" % (self.currentFolder)
os.system(action)
action = "cp %s/caseDicts/foamDataToFluentDict %s/system/foamDataToFluentDict" % (
os.path.dirname(os.path.realpath(__file__)),
self.currentFolder,
)
os.system(action)
parsedData = ParsedParameterFile("%s/system/foamDataToFluentDict" % self.currentFolder, createZipped=False)
ii = 10
for ifield in self.fields:
if ifield not in parsedData.getValueDict().keys():
parsedData[ifield] = ii
ii = ii + 1
action = "foamDataToFluent -case %s %s > %s &" % (self.currentFolder, tt, filename)
elif opt == "Ensight":
action = "foamToEnsight -case %s %s > %s &" % (self.currentFolder, tt, filename)
os.system(action)
return
def processABoundaryFile(self,func,targetDir):
"""
@param func: the function that transforms the actual boundary file
"""
boundaryPath=path.join(targetDir,self.opts.region,"polyMesh","boundary")
try:
boundary=ParsedParameterFile(boundaryPath,
debug=False,
boundaryDict=True,
treatBinaryAsASCII=True)
except IOError:
self.warning("Problem opening boundary file",boundaryPath)
return False
bnd=boundary.content
if type(bnd)!=list:
self.warning("Problem with boundary file (not a list)")
return False
boundary.content=func(bnd,targetDir)
if boundary.content:
if self.opts.test:
print_(boundary)
else:
boundary.writeFile()
# self.addToCaseLog(boundaryPath)
return True
else:
self.warning(boundaryPath,"unchanged")
return False
def load(self):
self.copy_template_folder()
# Parsed files
# ============
self._mesh_dict = ParsedParameterFile(
self.config_path('system/meshDict'))
self.__decompose_par_dict = ParsedParameterFile(
self.config_path('system/decomposeParDict'))
self.__control_dict = ParsedParameterFile(
self.config_path('system/controlDict'))
# Registered files
# ================
self.register_foam_file('system/meshDict', self._mesh_dict)
self.register_foam_file('system/decomposeParDict',
self.__decompose_par_dict)
self.register_foam_file('system/controlDict', self.__control_dict)
# Load refinementObjects
# ======================
self.object_refinements_load()
# Load function from Visualization module
# =======================================
self.visualization_load()
# Load output and vis objects when app finished
# =============================================
if self.status == FoamApp.FINISHED:
self.__output_mesh = FoamMesh(self.current_run_path())
self.__load_output_vis()
self.update_tree_view()
def __init__(self, currentFolder):
figureTracersUI.__init__(self)
self.currentFolder = currentFolder
self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(False)
[self.timedir,self.fields,bas] = currentFields(self.currentFolder)
filename = '%s/system/controlDict'%self.currentFolder
self.parsedData = ParsedParameterFile(filename,createZipped=False)
self.tracersData = []
if 'functions' in self.parsedData.getValueDict().keys():
for key in self.parsedData['functions'].keys():
if self.parsedData['functions'][key]['type'] == 'scalarTransport':
tracer = {}
tracer['name'] = key
tracer['patchName'] = self.parsedData['functions'][key]['patchName']
tracer['startTime'] = self.parsedData['functions'][key]['fvOptions']['S']['timeStart']
self.tracersData.append(tracer)
for tracer in self.tracersData:
item = QtGui.QListWidgetItem()
item.setCheckState(QtCore.Qt.Unchecked)
item.setText(tracer['name'])
self.listWidget.addItem(item)
from PyFoam.RunDictionary.BoundaryDict import BoundaryDict
boundaries = BoundaryDict(str(self.currentFolder))
for ipatch in boundaries.getValueDict():
if boundaries[ipatch]['type'] != 'empty':
self.comboBox.addItem(ipatch)
def run(self):
fName=self.parser.getArgs()[0]
destPatches=self.parser.getArgs()[1:]
if self.opts.patch==None and self.opts.value==None:
self.error("Either a patch or a value must be specified")
if self.opts.patch!=None and self.opts.value!=None:
self.error("Only a patch or a value can be specified")
try:
fieldFile=ParsedParameterFile(fName,backup=False)
except IOError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
self.error("Problem with file",fName,":",e)
value=""
if self.opts.patch:
value=fieldFile["boundaryField"][self.opts.patch][self.opts.srckey]
else:
value="uniform "+self.opts.value
for destPatch in destPatches:
fieldFile["boundaryField"][destPatch][self.opts.destkey]=value
if self.opts.test:
print_(str(fieldFile))
else:
fieldFile.writeFile()
def accept(self):
filename = '%s/system/controlDict' % (self.currentFolder)
parsedData = ParsedParameterFile(filename, createZipped=False)
if 'functions' not in parsedData.getValueDict().keys():
parsedData['functions'] = {}
#Logica para evitar nombres repetidos
for key in self.parsedData['functions'].keys():
if key == str(self.name.text()):
w = QtGui.QMessageBox(
QtGui.QMessageBox.Information, "Error",
"The name of the new figure and the name of the tracer must be different. Please select another name"
)
w.exec_()
return
dicc['outputInterval'] = self.spinBox.value()
fields = []
for i in range(self.listWidget.count()):
if self.listWidget.item(i).checkState() == QtCore.Qt.Checked:
fields.append(str(self.listWidget.item(i).text()))
dicc['fields'] = fields
dicc['sourceName'] = str(self.comboBox.currentText())
parsedData['functions'][str(self.name.text())] = dicc
parsedData.writeFile()
self.done(self.Accepted)
def accept(self):
filename = '%s/system/controlDict'%(self.currentFolder)
parsedData = ParsedParameterFile(filename,createZipped=False)
if 'functions' not in parsedData.getValueDict().keys():
parsedData['functions'] = {}
if str(self.name.text()) not in parsedData['functions'].keys():
parsedData['functions'][str(self.name.text())] = {}
parsedData['functions'][str(self.name.text())]['type'] = 'sets'
parsedData['functions'][str(self.name.text())]['outputControl'] = 'timeStep'
parsedData['functions'][str(self.name.text())]['outputInterval'] = self.spinBox.value()
parsedData['functions'][str(self.name.text())]['setFormat'] = 'raw'
parsedData['functions'][str(self.name.text())]['interpolationScheme'] = 'cellPoint'
ifield = self.comboBox.currentText()
if ifield not in self.fields:
#significa que es un vector
axis = 'distance' #ifield[-1]
ifield = ifield[0:-1]
else:
axis = 'distance' #por las dudas
parsedData['functions'][str(self.name.text())]['fields'] = [ifield]
dicc = {}
dicc['nPoints'] = self.nop.text()
dicc['start'] = '(%s %s %s)'%(str(self.p1_x.text()),str(self.p1_y.text()),str(self.p1_z.text()))
dicc['end'] = '(%s %s %s)'%(str(self.p2_x.text()),str(self.p2_y.text()),str(self.p2_z.text()))
dicc['type'] = 'uniform'
dicc['axis'] = axis
parsedData['functions'][str(self.name.text())]['sets'] = ['data',dicc]
parsedData.writeFile()
self.done(self.Accepted)
def case_setup(ci):
template_case = SolutionDirectory(
"template", archive=None, paraviewLink=False)
case = template_case.cloneCase(
"{0}NC{1}".format(ci.name, ci.nr_classes)
)
phase_properties = ParsedParameterFile(
path.join(template_case.name, "constant", "phaseProperties"))
phase_properties["oil"]["PBEDiameterCoeffs"]["MOCCoeffs"]["numberOfClasses"] = ci.nr_classes
phase_properties["oil"]["PBEDiameterCoeffs"]["MOCCoeffs"]["xi1"] = ci.dv
# manually fix bad pyfoam parsing
phase_properties["blending"]["default"]["type"] = "none"
phase_properties["drag"][1]["swarmCorrection"]["type"] = "none"
phase_properties.writeFileAs(path.join(
case.name, "constant", "phaseProperties"
))
n0 = ParsedParameterFile(path.join(template_case.name, "0", "n0"))
for i in range(ci.nr_classes):
n0.header["object"] = "n" + str(i)
n0["internalField"].setUniform(ci.Ninit[i])
n0.writeFileAs(path.join(case.name, "0", "n" + str(i)))
controlDict = ParsedParameterFile(
path.join(case.name, "system", "controlDict")
)
controlDict["functions"]["probes"]["fields"] = [
"n{0}".format(n) for n in range(ci.nr_classes)]
controlDict.writeFile()
def accept(self):
filename = '%s/system/controlDict'%(self.currentFolder)
parsedData = ParsedParameterFile(filename,createZipped=False)
if 'functions' not in parsedData.getValueDict().keys():
parsedData['functions'] = {}
#Logica para evitar nombres repetidos
for key in self.parsedData['functions'].keys():
if key == str(self.name.text()):
w = QtGui.QMessageBox(QtGui.QMessageBox.Information, "Error", "The name of the new figure and the name of the tracer must be different. Please select another name")
w.exec_()
return
dicc['outputInterval'] = self.spinBox.value()
fields = []
for i in range(self.listWidget.count()):
if self.listWidget.item(i).checkState() == QtCore.Qt.Checked:
fields.append(str(self.listWidget.item(i).text()))
dicc['fields'] = fields
dicc['sourceName'] = str(self.comboBox.currentText())
parsedData['functions'][str(self.name.text())] = dicc
parsedData.writeFile()
self.done(self.Accepted)
def testReadTutorial(self):
test=ParsedParameterFile(self.theFile,listLengthUnparsed=100)
data1=deepcopy(test.content)
open(self.theFile,"w").write(str(FoamFileGenerator(data1,header=test.header)))
del test
test2=ParsedParameterFile(self.theFile,listLengthUnparsed=100)
self.assertEqual(data1,test2.content)
def run(self):
fName=self.parser.getArgs()[0]
bName=self.parser.getArgs()[1]
tName=self.parser.getArgs()[2]
boundaryPath=path.join(".",fName,self.opts.time,self.opts.region,"polyMesh","boundary")
try:
boundary=ParsedParameterFile(boundaryPath,debug=False,boundaryDict=True)
except IOError:
self.error("Problem opening boundary file",boundaryPath)
bnd=boundary.content
if type(bnd)!=list:
self.error("Problem with boundary file (not a list)")
found=False
for val in bnd:
if val==bName:
found=True
elif found:
val["type"]=tName
break
if not found:
self.error("Boundary",bName,"not found in",bnd[::2])
if self.opts.test:
print_(boundary)
else:
boundary.writeFile()
self.addToCaseLog(fName)
def case_setup(ci):
template_case = SolutionDirectory(
"template", archive=None, paraviewLink=False)
case = template_case.cloneCase(
"{0}{1}".format(ci.name, ci.quadrature_order)
)
phase_properties = ParsedParameterFile(
path.join("./diffs", ci.phase_properties_name))
phase_properties["air"]["PBEDiameterCoeffs"]["QMOMCoeffs"]["quadratureOrder"] = ci.quadrature_order
# manually fix bad pyfoam parsing
phase_properties["blending"]["default"]["type"] = "none"
phase_properties["drag"][1]["swarmCorrection"]["type"] = "none"
phase_properties.writeFileAs(path.join(
case.name, "constant", "phaseProperties"
))
m0 = ParsedParameterFile(path.join(template_case.name, "0", "m0"))
for i in range(ci.number_of_moments):
m0.header["object"] = "m" + str(i)
m0["internalField"].setUniform(ci.initial_moments[i])
m0["dimensions"] = "[0 {0} 0 0 0 0 0]".format(3 * i)
m0.writeFileAs(path.join(case.name, "0", "m" + str(i)))
controlDict = ParsedParameterFile(
path.join(case.name, "system", "controlDict")
)
controlDict["functions"]["probes"]["fields"] = [
"m{0}".format(m) for m in range(ci.number_of_moments)]
controlDict["endTime"] = ci.end_time
controlDict["deltaT"] = ci.delta_t
controlDict.writeFile()
def __init__(self, sol, libs, funs):
self.control = ParsedParameterFile(path.join(sol.systemDir(),
"controlDict"),
backup=True,
doMacroExpansion=True)
self.fresh = False
try:
if libs and ("libs" in self.control):
warning(
"Temporarily removing the libs-entry from the controlDict")
del self.control["libs"]
self.fresh = True
if funs and ("functions" in self.control):
warning(
"Temporarily removing the functions-entry from the controlDict"
)
del self.control["functions"]
self.fresh = True
if self.fresh:
self.control.writeFile()
else:
self.control.restore()
except Exception:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
warning("Restoring defaults")
self.control.restore()
raise e
def __init__(self,sol,correctors,tolerance,relTol,pRefValue=None,pRefCell=None):
self.solution=ParsedParameterFile(path.join(sol.systemDir(),"fvSolution"),backup=True)
self.schemes=ParsedParameterFile(path.join(sol.systemDir(),"fvSchemes"),backup=True)
self.control=ParsedParameterFile(path.join(sol.systemDir(),"controlDict"),backup=True)
self.controlOrig=ParsedParameterFile(path.join(sol.systemDir(),"controlDict"),backup=False)
pre=environ["FOAM_TUTORIALS"]
if not oldTutorialStructure():
pre=path.join(pre,"basic")
pot=SolutionDirectory(path.join(pre,"potentialFoam","cylinder"),archive=None,paraviewLink=False)
self.fresh=True
try:
if "SIMPLE" not in self.solution:
self.solution["SIMPLE"]=ParsedParameterFile(path.join(pot.systemDir(),"fvSolution"),backup=False)["SIMPLE"]
if "nNonOrthogonalCorrectors" not in self.solution["SIMPLE"] and correctors==None:
correctors=3
warning("Setting number of correctors to default value",correctors)
if correctors!=None:
self.solution["SIMPLE"]["nNonOrthogonalCorrectors"]=correctors
if pRefCell!=None:
self.solution["SIMPLE"]["pRefCell"]=pRefCell
if pRefValue!=None:
self.solution["SIMPLE"]["pRefValue"]=pRefValue
if tolerance!=None:
try:
self.solution["solvers"]["p"][1]["tolerance"]=tolerance
except KeyError:
# 1.6 format
self.solution["solvers"]["p"]["tolerance"]=tolerance
if relTol!=None:
try:
self.solution["solvers"]["p"][1]["relTol"]=relTol
except KeyError:
# 1.6 format
self.solution["solvers"]["p"]["relTol"]=relTol
self.schemes.content=ParsedParameterFile(path.join(pot.systemDir(),"fvSchemes"),backup=False).content
self.control.content=ParsedParameterFile(path.join(pot.systemDir(),"controlDict"),backup=False).content
if "functions" in self.controlOrig:
print "Copying functions over"
self.control["functions"]=self.controlOrig["functions"]
if "libs" in self.controlOrig:
print "Copying libs over"
self.control["libs"]=self.controlOrig["libs"]
self.solution.writeFile()
self.schemes.writeFile()
self.control.writeFile()
except Exception,e:
warning("Restoring defaults")
self.solution.restore()
self.schemes.restore()
self.control.restore()
raise e
def __init__(self, sol, writeAll, purge, until):
self.control = ParsedParameterFile(path.join(sol.systemDir(),
"controlDict"),
backup=True,
doMacroExpansion=True)
self.fresh = True
try:
if writeAll:
self.control["writeControl"] = "timeStep"
self.control["writeInterval"] = "1"
if purge != None:
self.control["purgeWrite"] = purge
if until != None:
self.control["endTime"] = until
self.control.writeFile()
except Exception:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
warning("Restoring defaults")
self.control.restore()
raise e
def run(self):
fName = self.parser.getArgs()[0]
destPatches = self.parser.getArgs()[1:]
if self.opts.patch == None and self.opts.value == None:
self.error("Either a patch or a value must be specified")
if self.opts.patch != None and self.opts.value != None:
self.error("Only a patch or a value can be specified")
try:
fieldFile = ParsedParameterFile(fName, backup=False)
except IOError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
self.error("Problem with file", fName, ":", e)
value = ""
if self.opts.patch:
value = fieldFile["boundaryField"][self.opts.patch][
self.opts.srckey]
else:
value = "uniform " + self.opts.value
for destPatch in destPatches:
fieldFile["boundaryField"][destPatch][self.opts.destkey] = value
if self.opts.test:
print_(str(fieldFile))
else:
fieldFile.writeFile()
def changePatchType(self, item):
w = bcPatch(self.boundaries[item.text()]['type'])
result = w.exec_()
if result:
patchType = w.getPatchType()
self.boundaries[item.text()]['type'] = patchType
self.boundaries.writeFile()
for ifield in self.fields:
filename = '%s/%s' % (self.timedir, ifield)
fieldData = ParsedParameterFile(filename, createZipped=False)
newDict = {}
if patchType == 'empty':
newDict['type'] = 'empty'
else:
if ifield in unknowns:
newDict['type'] = 'zeroGradient'
else:
newDict['type'] = 'calculated'
fieldData['boundaryField'][item.text()] = newDict
fieldData.writeFile()
self.loadData()
def processABoundaryFile(self,func,targetDir):
"""
:param func: the function that transforms the actual boundary file
"""
boundaryPath=path.join(targetDir,"polyMesh","boundary")
try:
boundary=ParsedParameterFile(boundaryPath,
debug=False,
boundaryDict=True,
treatBinaryAsASCII=True)
except IOError:
self.warning("Problem opening boundary file",boundaryPath)
return False
bnd=boundary.content
if type(bnd)!=list:
self.warning("Problem with boundary file (not a list)")
return False
boundary.content=func(bnd,targetDir)
if boundary.content:
if self.opts.test:
print_(boundary)
else:
boundary.writeFile()
# self.addToCaseLog(boundaryPath)
return True
else:
self.warning(boundaryPath,"unchanged")
return False
def execute(self, para, log):
f = replaceValues(self.filename, para)
v = replaceValues(self.value, para)
s = replaceValues(self.subexpression, para)
k = replaceValues(self.key, para)
try:
dictFile = ParsedParameterFile(f, backup=True)
val = dictFile[k]
except KeyError:
self.error("Key: ", k, "not existing in File", f)
except IOError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
self.error("Problem with file", k, ":", e)
try:
exec_("dictFile[k]" + s + "=v")
except Exception:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
error("Problem with subexpression:", sys.exc_info()[0], ":", e)
dictFile.writeFile()
return True, None
def __init__(self,
templateDict='',
interval=1,
field='p',
point=[0., 0., 0.]):
super(Probe, self).__init__(name='probe')
try:
if (str(templateDict).split("/")[-1] != "controlDict"):
raise ValueError
check_file(templateDict)
except ValueError:
raise ValueError('File controlDict should be provided by user')
try:
if (int(interval) <= 0):
raise ValueError
#todo field check
#if(str(field)!=("p"))
if (len(point) != 3):
raise ValueError
except ValueError:
raise ValueError('Not valid parameters for Probe')
#all checks passed
self.controlDict = ParsedParameterFile(templateDict)
self.interval = interval
self.field = field
self.probeCoords = []
strPoint = str('(' + ' '.join(map(str, point)) + ')')
self.probeCoords.append(strPoint)
def case_setup(ci):
template_case = SolutionDirectory("template",
archive=None,
paraviewLink=False)
case = template_case.cloneCase("{0}{1}".format(ci.name, ci.nr_classes))
phase_properties = ParsedParameterFile(
path.join("./diffs", ci.phase_properties_name))
phase_properties["air"]["PBEDiameterCoeffs"]["MOCCoeffs"][
"numberOfClasses"] = ci.nr_classes
phase_properties["air"]["PBEDiameterCoeffs"]["MOCCoeffs"]["xi1"] = ci.dv
# manually fix bad pyfoam parsing
phase_properties["blending"]["default"]["type"] = "none"
phase_properties["drag"][1]["swarmCorrection"]["type"] = "none"
phase_properties.writeFileAs(
path.join(case.name, "constant", "phaseProperties"))
v = ci.dv + ci.dv * arange(ci.nr_classes)
n0 = ParsedParameterFile(path.join(template_case.name, "0", "n0"))
for i in range(ci.nr_classes):
n0.header["object"] = "n" + str(i)
n0["internalField"].setUniform(ci.Ninit(v[i]))
n0.writeFileAs(path.join(case.name, "0", "n" + str(i)))
controlDict = ParsedParameterFile(
path.join(case.name, "system", "controlDict"))
controlDict["functions"]["probes"]["fields"] = [
"n{0}".format(n) for n in range(ci.nr_classes)
]
controlDict["endTime"] = ci.end_time
controlDict["deltaT"] = ci.delta_t
controlDict.writeFile()
def setData(self,data):
#self.spinBox.setValue(data['nsteps']) if 'nsteps' in data.keys() else None
#self.nop.setValue(data['nop']) if 'nop' in data.keys() else None
self.name.setText(data['name']) if 'name' in data.keys() else None
#self.comboBox.setCurrentText(data['field']) if 'field' in data.keys() else None
#self.comboBox.setCurrentText(data['autorefreshing']) if 'autorefreshing' in data.keys() else None
self.p1_x.setText(data['p1x']) if 'p1x' in data.keys() else None
self.p1_y.setText(data['p1y']) if 'p1y' in data.keys() else None
self.p1_z.setText(data['p1z']) if 'p1z' in data.keys() else None
self.p2_x.setText(data['p2x']) if 'p2x' in data.keys() else None
self.p2_y.setText(data['p2y']) if 'p2y' in data.keys() else None
self.p2_z.setText(data['p2z']) if 'p2z' in data.keys() else None
filename = '%s/system/controlDict'%(self.currentFolder)
parsedData = ParsedParameterFile(filename,createZipped=False)
if 'functions' in parsedData.getValueDict().keys():
if data['name'] in parsedData['functions'].keys():
dicc = parsedData['functions'][data['name']]
if dicc['type']=='sets':
self.name.setText(data['name'])
self.spinBox.setValue(dicc['outputInterval'])
return data
def write(self):
"""
Updates the values for the turbulent flow properties and writes all
**turbulent** boundary files. Wallfunctions, if used, are updated as
well.
"""
for bcI in self.turbBC:
for inletPatchI in self.case.inletPatch:
bcFile = ParsedParameterFile(
join(
self.case.name,
self.case.first,
bcI
)
)
# Set the internal field and the inlet patch at first
bcFile['internalField'] = "uniform %f" %(self.vars[bcI])
bcFile['boundaryField'][inletPatchI]['value'] = \
"uniform %f" %(self.vars[bcI])
# Update the wallfunctions if they are used
for patchI in bcFile['boundaryField']:
if "allFunction" in bcFile['boundaryField'][patchI]['type']:
bcFile['boundaryField'][patchI]['value'] = \
"uniform %f" %(self.vars[bcI])
# Write the current boundary file
bcFile.writeFile()
def accept(self):
filename = '%s/system/controlDict' % (self.currentFolder)
parsedData = ParsedParameterFile(filename, createZipped=False)
if 'functions' not in parsedData.getValueDict().keys():
parsedData['functions'] = {}
if str(self.name.text()) not in parsedData['functions'].keys():
parsedData['functions'][str(self.name.text())] = {}
parsedData['functions'][str(self.name.text())]['type'] = 'residuals'
parsedData['functions'][str(
self.name.text())]['outputControl'] = 'timeStep'
parsedData['functions'][str(
self.name.text())]['outputInterval'] = self.spinBox.value()
parsedData['functions'][str(
self.name.text())]['functionObjectLibs'] = [
'"libutilityFunctionObjects.so"'
]
fields = []
for i in range(self.listWidget.count()):
if self.listWidget.item(i).checkState() == QtCore.Qt.Checked:
fields.append(str(self.listWidget.item(i).text()))
parsedData['functions'][str(self.name.text())]['fields'] = fields
parsedData.writeFile()
self.done(self.Accepted)
def writeOFBoundaries(self):
"""Write boundary conditions to 0/<field> file in case directory."""
for field in self.boundaries:
f = ParsedParameterFile(os.path.join(self.casename, "0/" + field))
for boundary in self.boundaries[field]:
f["boundaryField"][boundary] = self.boundaries[field][boundary]
f.writeFile()
def accept(self):
filename = '%s/system/controlDict'%(self.currentFolder)
parsedData = ParsedParameterFile(filename,createZipped=False)
if 'functions' not in parsedData.getValueDict().keys():
parsedData['functions'] = {}
#Logica para evitar que se llamen T* (como los tracers)
# if len(str(self.name.text()))>=2 and self.name.text()[0]=='T':
# for i in range(1,len(str(self.name.text()))):
# if ()
#Logica para evitar nombres repetidos
for key in parsedData['functions'].keys():
if key == str(self.name.text()):
w = QtGui.QMessageBox(QtGui.QMessageBox.Information, "Error", "The name of the new figure and the name of the field must be different. Please select another name")
w.exec_()
return
if str(self.name.text()) not in parsedData['functions'].keys():
parsedData['functions'][str(self.name.text())] = {}
parsedData['functions'][str(self.name.text())]['type'] = 'residuals'
parsedData['functions'][str(self.name.text())]['outputControl'] = 'timeStep'
parsedData['functions'][str(self.name.text())]['outputInterval'] = self.spinBox.value()
parsedData['functions'][str(self.name.text())]['functionObjectLibs'] = ['"libutilityFunctionObjects.so"']
fields = []
for i in range(self.listWidget.count()):
if self.listWidget.item(i).checkState() == QtCore.Qt.Checked:
fields.append(str(self.listWidget.item(i).text()))
parsedData['functions'][str(self.name.text())]['fields'] = fields
parsedData.writeFile()
self.done(self.Accepted)
def saveUserLibrary(self):
filename = 'caseDicts/materialProperties.incompressible'
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['userLibrary'] = self.userLibrary
parsedData.writeFile()
return
def run(self):
fName=self.parser.getArgs()[0]
bName=self.parser.getArgs()[1]
tName=self.parser.getArgs()[2]
boundaryPath=path.join(".",fName,self.opts.time,self.opts.region,"polyMesh","boundary")
try:
boundary=ParsedParameterFile(boundaryPath,debug=False,boundaryDict=True)
except IOError:
self.error("Problem opening boundary file",boundaryPath)
bnd=boundary.content
if type(bnd)!=list:
self.error("Problem with boundary file (not a list)")
found=False
for val in bnd:
if val==bName:
found=True
elif found:
val["type"]=tName
break
if not found:
self.error("Boundary",bName,"not found in",bnd[::2])
if self.opts.test:
print_(boundary)
else:
boundary.writeFile()
self.addToCaseLog(fName)
def writeOFBoundaries(self): """Write boundary conditions to 0/<field> file in case directory.""" for field in self.boundaries: f = ParsedParameterFile(os.path.join(self.casename, "0/" + field)) for boundary in self.boundaries[field]: f["boundaryField"][boundary] = self.boundaries[field][boundary] f.writeFile()
def __init__(self,sol,factor):
self.solution=ParsedParameterFile(path.join(sol.systemDir(),"fvSolution"),backup=True)
self.schemes=ParsedParameterFile(path.join(sol.systemDir(),"fvSchemes"),backup=True)
self.fresh=True
try:
relax=self.solution["relaxationFactors"]
for var in relax:
relax[var]*=factor
cExp=re.compile("div\((.+),(.+)\)")
conv=self.schemes["divSchemes"]
for nm in conv:
if cExp.match(nm) or nm=="default":
conv[nm]="Gauss upwind"
self.solution.writeFile()
self.schemes.writeFile()
except Exception:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
warning("Restoring defaults")
self.solution.restore()
self.schemes.restore()
raise e
def saveUserLibrary(self):
filename = 'caseDicts/materialProperties.incompressible'
parsedData = ParsedParameterFile(filename, createZipped=False)
parsedData['userLibrary'] = self.userLibrary
parsedData.writeFile()
return
def saveUserLibrary(self):
filename = '%s/.config/petroSym/materialProperties.incompressible'%self.home #Path en home
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['userLibrary'] = self.userLibrary
parsedData.writeFile()
return
def __init__(self, sol, factor):
self.solution = ParsedParameterFile(path.join(sol.systemDir(),
"fvSolution"),
backup=True)
self.schemes = ParsedParameterFile(path.join(sol.systemDir(),
"fvSchemes"),
backup=True)
self.fresh = True
try:
relax = self.solution["relaxationFactors"]
for var in relax:
relax[var] *= factor
cExp = re.compile("div\((.+),(.+)\)")
conv = self.schemes["divSchemes"]
for nm in conv:
if cExp.match(nm) or nm == "default":
conv[nm] = "Gauss upwind"
self.solution.writeFile()
self.schemes.writeFile()
except Exception:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
warning("Restoring defaults")
self.solution.restore()
self.schemes.restore()
raise e
def edit_velocity(dictionary, domain_json, velocity=1):
"""
Edit the initial velocity file for CFD simulation
:param str dictionary: File path of the velocity dictionary, (0/U)
:param str domain_json: File path of vessel inlet description json
:param float velocity: Inlet velocity magnitude (cm/s)
"""
try:
tqdm.write("{}: Editing velocity file: {}".format(
datetime.datetime.now(), dictionary))
velocityDict = ParsedParameterFile(dictionary)
with open(domain_json, 'r') as f:
domain_dict = json.load(f)
boundaryField = {
"vessel": {
"type": "noSlip"
},
"walls": {
"type": "empty"
}
}
for key, value in domain_dict.items():
try:
if value["type"] == "inlet":
boundaryField.update({key: {
"type": "fixedValue",
"value": "uniform (" +\
str(value["tangent"][0]/100*velocity) + " " + \
str(value["tangent"][1]/100*velocity) + " " + \
str(value["tangent"][2]/100*velocity) + ")"}})
elif value["type"] == "outlet":
boundaryField.update({
key: {
"type": "inletOutlet",
"inletValue": "uniform (0 0 0)",
"value": "uniform (0 0 0)"
}
})
else:
continue
except:
continue
velocityDict["boundaryField"] = boundaryField
try:
velocityDict.writeFile()
except IOError:
tqdm.write("Can't write file. Content would have been:")
tqdm.write(velocityDict)
except IOError:
tqdm.write(dictionary, " does not exist")
return 1
def testReadTutorialWithMacros(self):
test=ParsedParameterFile(self.theFile,
listLengthUnparsed=100,
doMacroExpansion=True)
data1=deepcopy(test.content)
open(self.theFile,"w").write(str(FoamFileGenerator(data1,header=test.header)))
del test
test2=ParsedParameterFile(self.theFile,listLengthUnparsed=100,doMacroExpansion=True)
self.compareData(data1,test2.content)
def compareFile(file1, file2, name1="1", name2="2", valName=""):
f1 = ParsedParameterFile(file1)
f2 = ParsedParameterFile(file2)
comparePyFoam(f1.content,
f2.content,
name1=name1,
name2=name2,
valName=valName)
def testBasicInclude(self):
if foamVersionNumber()<(2,):
return
test=ParsedParameterFile(self.theFile)
data1=deepcopy(test.content)
open(self.theFile,"w").write(str(FoamFileGenerator(data1,header=test.header)))
del test
test2=ParsedParameterFile(self.theFile)
self.assertEqual(data1,test2.content)
def aplicar(self):
filename = '%s/system/fvSolution'%self.currentFolder
parsedData = ParsedParameterFile(filename,createZipped=False)
#modify data
parsedData.writeFile()
self.pushButton.setEnabled(False)
return
def testReadTutorial(self):
test=ParsedParameterFile(self.theFile)
data1=deepcopy(test.content)
open(self.theFile,"w").write(str(FoamFileGenerator(data1,header=test.header)))
del test
test2=ParsedParameterFile(self.theFile)
self.assertEqual(data1,test2.content)
test3=ParsedParameterFile(self.theFile+".gz")
self.assertEqual(data1,test3.content)
def saveCaseData(self, doTopoSet=False):
for dd in self.tracersData:
del self.parsedData["functions"][dd["name"]]
if "functions" not in self.parsedData.getValueDict().keys():
self.parsedData["functions"] = {}
patches = []
for i in range(self.tableWidget.rowCount()):
patchName = str(self.tableWidget.cellWidget(i, 1).currentText())
newkey = "T%s" % str(i)
tracer = copy.deepcopy(dicc)
cellsetname = "%s_c" % patchName
tracer["fvOptions"]["S"]["timeStart"] = str(self.tableWidget.cellWidget(i, 0).text())
tracer["fvOptions"]["S"]["cellSet"] = cellsetname
tracer["patchName"] = patchName
del tracer["fvOptions"]["S"]["scalarExplicitSetValueCoeffs"]["injectionRate"]["T0"]
tracer["fvOptions"]["S"]["scalarExplicitSetValueCoeffs"]["injectionRate"][newkey] = "1"
self.parsedData["functions"][newkey] = tracer
patches.append(patchName)
self.parsedData.writeFile()
# self.parsedData.closeFile()
if doTopoSet:
spatches = set(patches)
ii = 0
cmd = "cp caseDicts/topoSetDict %s/system/." % self.currentFolder
os.system(cmd)
filename = "%s/system/topoSetDict" % self.currentFolder
topoSetData = ParsedParameterFile(filename, createZipped=False)
# armo el topoSet de manera de generar los cellSet deseados
for ipatch in spatches:
cellsetname = "%s_c" % ipatch
facesetname = "%s_f" % ipatch
if not os.path.isfile("%s/constant/polyMesh/sets/%s" % (self.currentFolder, cellsetname)):
if ii > 0:
topoSetData["actions"].append(topoSetData["actions"][0])
topoSetData["actions"].append(topoSetData["actions"][1])
topoSetData["actions"][ii]["name"] = facesetname
topoSetData["actions"][ii]["sourceInfo"]["name"] = ipatch
topoSetData["actions"][ii + 1]["name"] = cellsetname
topoSetData["actions"][ii + 1]["sourceInfo"]["set"] = facesetname
ii = ii + 2
topoSetData.writeFile()
cmd = "topoSet -case %s > run_topoSet.log &" % self.currentFolder
os.system(cmd)
else:
self.loadCaseData()
self.refreshTable()
self.refreshTimeline()
return
def stopRun(self):
filename = '%s/system/controlDict'%self.currentFolder
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['stopAt'] = 'writeNow'
parsedData.writeFile()
time.sleep(0.1)
self.findChild(QtGui.QPushButton,'pushButton_3').setEnabled(False)
# while 1:
# command = 'ps | cut -d " " -f 7 | grep Foam > %s/runningNow'%self.currentFolder
# os.system(command)
# f = open('%s/runningNow'%self.currentFolder, 'r')
# if not f.read():
# break
# f.close()
# time.sleep(0.1)
import psutil
import utils
self.progress = QtGui.QProgressBar()
self.progress.setWindowTitle("Saving the current data... Hold tight")
resolution = utils.get_screen_resolutions()
self.progress.setGeometry(int(resolution[0])/2 - 175,int(resolution[1])/2,350,30)
self.progress.show()
i=0
while psutil.pid_exists(self.window().runningpid):
#retraso un minuto la edicion del control dict
tt = list(localtime())
tt[4] = (tt[4]+1)%60 #Agrego el modulo porque cuando el min es 0, 0-1 = -1
command = 'touch -d "%s" %s'%(strftime("%Y-%m-%d %H:%M:%S", struct_time(tuple(tt))),filename)
os.system(command)
self.progress.setValue(i)
QtGui.QApplication.processEvents()
i=i+0.1
time.sleep(0.1)
self.progress.setValue(100)
self.progress.close()
if psutil.pid_exists(self.window().runningpid):
command = 'kill %s'%self.window().runningpid
os.system(command)
self.window().runningpid = -1
self.window().save_config()
self.window().runW.pushButton_run.setEnabled(True)
self.window().runW.pushButton_reset.setEnabled(True)
self.window().tab_mesh.setEnabled(True)
self.window().refresh_pushButton.setEnabled(True)
leave = [1,5]
for i in range(self.window().treeWidget.topLevelItemCount()):
if i not in leave:
self.window().treeWidget.topLevelItem(i).setDisabled(False)
def saveCaseData(self, doTopoSet=False):
for dd in self.tracersData:
del self.parsedData['functions'][dd['name']]
if 'functions' not in self.parsedData.getValueDict().keys():
self.parsedData['functions'] = {}
patches = []
for i in range(self.tableWidget.rowCount()):
patchName = str(self.tableWidget.cellWidget(i,1).currentText())
newkey = 'T%s'%str(i)
tracer = copy.deepcopy(dicc)
cellsetname = '%s_c'%patchName
tracer['fvOptions']['S']['timeStart'] = str(self.tableWidget.cellWidget(i,0).text())
tracer['fvOptions']['S']['cellSet'] = cellsetname
tracer['patchName'] = patchName
del tracer['fvOptions']['S']['scalarExplicitSetValueCoeffs']['injectionRate']['T0']
tracer['fvOptions']['S']['scalarExplicitSetValueCoeffs']['injectionRate'][newkey] = '1'
self.parsedData['functions'][newkey] = tracer
patches.append(patchName)
self.parsedData.writeFile()
#self.parsedData.closeFile()
if doTopoSet:
spatches = set(patches)
ii = 0
cmd = 'cp %s/caseDicts/topoSetDict %s/system/.'%(os.path.dirname(__file__),self.currentFolder)
os.system(cmd)
filename = '%s/system/topoSetDict'%self.currentFolder
topoSetData = ParsedParameterFile(filename,createZipped=False)
#armo el topoSet de manera de generar los cellSet deseados
for ipatch in spatches:
cellsetname = '%s_c'%ipatch
facesetname = '%s_f'%ipatch
if not os.path.isfile('%s/constant/polyMesh/sets/%s'%(self.currentFolder,cellsetname)):
if ii>0:
topoSetData['actions'].append(topoSetData['actions'][0])
topoSetData['actions'].append(topoSetData['actions'][1])
topoSetData['actions'][ii]['name'] = facesetname
topoSetData['actions'][ii]['sourceInfo']['name'] = ipatch
topoSetData['actions'][ii+1]['name'] = cellsetname
topoSetData['actions'][ii+1]['sourceInfo']['set'] = facesetname
ii = ii+2
topoSetData.writeFile()
cmd = 'topoSet -case %s > run_topoSet.log &'%self.currentFolder
os.system(cmd)
else:
self.loadCaseData()
self.refreshTable()
self.refreshTimeline()
return
def runCase(self):
[self.timedir,self.fields,self.currtime] = currentFields(self.currentFolder,nproc=self.window().nproc)
# if self.window().nproc>1:
# w = QtGui.QMessageBox(QtGui.QMessageBox.Information, "Is the case decomposed?", "Simulation will be done only if case decompositione was done previously. Continue?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
# ret = w.exec_()
# if(QtGui.QMessageBox.No == ret):
# return
#modifico el control dict porque pude haber parado la simulacion
filename = '%s/system/controlDict'%self.currentFolder
parsedData = ParsedParameterFile(filename,createZipped=False)
parsedData['stopAt'] = 'endTime'
parsedData.writeFile()
self.window().removeFilesPostPro()
#retraso un minuto la edicion del control dict
tt = list(localtime())
tt[4] = (tt[4]-1)%60 #Agrego el modulo porque cuando el min es 0, 0-1 = -1
command = 'touch -d "%s" %s'%(strftime("%Y-%m-%d %H:%M:%S", struct_time(tuple(tt))),filename)
os.system(command)
filename1 = '%s/run.log'%self.currentFolder
filename2 = '%s/error.log'%self.currentFolder
self.window().newLogTab('Run',filename1)
if self.window().nproc<=1:
command = '%s -case %s 1> %s 2> %s &'%(self.solvername,self.currentFolder,filename1,filename2)
else:
command = 'mpirun -np %s %s -case %s -parallel 1> %s 2> %s & '%(str(self.window().nproc),self.solvername,self.currentFolder,filename1, filename2)
os.system(command)
if self.window().nproc<=1:
command = 'pidof %s'%self.solvername
else:
command = 'pidof mpirun'
import subprocess
self.window().runningpid = subprocess.check_output(command, shell=True)
self.window().runningpid.replace('\n','') #Me lo devuelve con un espacio al final
self.window().runningpid = int(self.window().runningpid) #Y como string
self.window().save_config()
self.pushButton_run.setEnabled(False)
self.pushButton_reset.setEnabled(False)
self.window().tab_mesh.setEnabled(False)
self.window().refresh_pushButton.setEnabled(False)
leave = [1,5]
for i in range(self.window().treeWidget.topLevelItemCount()):
if i not in leave:
self.window().treeWidget.topLevelItem(i).setDisabled(True)
self.window().findChild(logTab,'%s/run.log'%self.currentFolder).findChild(QtGui.QPushButton,'pushButton_3').setEnabled(True)
self.window().updateLogFiles()
def case_setup(ci):
template_case = SolutionDirectory(
"template", archive=None, paraviewLink=False)
case = template_case.cloneCase("{0}".format(ci.name))
stfproperties = ParsedParameterFile(path.join(
case.name, "constant", "STFProperties"))
stfproperties["apparentMass"] = ci.ma
stfproperties["mass"] = ci.m
stfproperties.writeFile()
def loadCaseData(self):
filename = '%s/constant/g'%self.currentFolder
if os.path.isfile(filename):
self.parsedData = ParsedParameterFile(filename,createZipped=False)
else:
command = 'cp %s/templates/template_%s/constant/g %s/constant/.'% (os.path.dirname(os.path.realpath(__file__)),self.currentSolver,self.currentFolder)
os.system(command)
self.parsedData = ParsedParameterFile(filename,createZipped=False)
self.gx.setText(str(self.parsedData['value'][0]))
self.gy.setText(str(self.parsedData['value'][1]))
self.gz.setText(str(self.parsedData['value'][2]))
def sampleDictionaries(self, cases, work, wind_dict):
# TODO - at the moment for 90 degrees phi only and in line instead of in a function
for case in cases:
self._r.status('preparing Sample file for case '+case.name)
sampleFile = ParsedParameterFile(path.join(case.systemDir(), "sampleDict"))
del sampleFile.content['sets'][:]
if len(wind_dict["Measurements"]) > 0:
self._r.status("creating sample locations for measurements")
for metMast in wind_dict["Measurements"]:
self._r.status("adding met mast " + metMast)
# creating sub directory entry
sampleFile.content['sets'].append(metMast)
# creating another fictional sub directory entry - so that i can run it over in a second
sampleFile.content['sets'].append([metMast])
sampleFile['sets'][len(sampleFile['sets'])-1] = \
{'type':'uniform', 'axis':'z',\
'start':'('+str(wind_dict["Measurements"][metMast]["x"])+" "\
+str(wind_dict["Measurements"][metMast]["y"])+" "\
+str(wind_dict["Measurements"][metMast]["gl"])+")",\
'end': '('+str(wind_dict["Measurements"][metMast]["x"])+" "\
+str(wind_dict["Measurements"][metMast]["y"])+" "\
+str(wind_dict["Measurements"][metMast]["gl"]+\
wind_dict["Measurements"][metMast]["h"])+")",\
'nPoints':wind_dict['sampleParams']['nPoints']}
if len(wind_dict['sampleParams']['metMasts'])>0:
self._r.status("creating sample locations for sampleParams")
for metMast in wind_dict['sampleParams']['metMasts']:
# creating sub directory entry
sampleFile.content['sets'].append(metMast)
# creating another fictional sub directory entry - so that i can run it over in a second
sampleFile.content['sets'].append([metMast])
sampleFile['sets'][len(sampleFile['sets'])-1] = \
{'type':'uniform', 'axis':'z',\
'start':'('+str(wind_dict["sampleParams"]["metMasts"][metMast]["x"])+" "\
+str(wind_dict["sampleParams"]["metMasts"][metMast]["y"])+" "\
+str(wind_dict["sampleParams"]["metMasts"][metMast]["gl"])+")",\
'end': '('+str(wind_dict["sampleParams"]["metMasts"][metMast]["x"])+" "\
+str(wind_dict["sampleParams"]["metMasts"][metMast]["y"])+" "\
+str(wind_dict["sampleParams"]["metMasts"][metMast]["gl"]+\
wind_dict["sampleParams"]["metMasts"][metMast]["h"])+")",\
'nPoints':wind_dict['sampleParams']['nPoints']}
del sampleFile.content['surfaces'][:]
for i,h in enumerate(wind_dict['sampleParams']['hSample']):
self._r.status('preparing sampling surface at '+str(h)+' meters agl')
translateSTL.stl_shift_z_filenames(path.join(case.name,'constant/triSurface/terrain.stl'), path.join(case.name,'constant/triSurface/terrain_agl_'+str(h)+'.stl'), h)
# creating sub directory entry
sampleFile.content['surfaces'].append('agl_'+str(h))
# creating another fictional sub directory entry - so that i can run it over in a second
sampleFile.content['surfaces'].append(['agl_'+str(h)])
sampleFile['surfaces'][len(sampleFile['surfaces'])-1]={'type':'sampledTriSurfaceMesh','surface':'terrain_agl_'+str(h)+'.stl','source':'cells'}
sampleFile.writeFile()
self._r.status('Sampling case '+case.name)
Runner(args=["sample" ,"-latestTime", "-case" ,case.name])
def __init__(self,
name,
backup=False,
debug=False,
doMacroExpansion=False):
ParsedParameterFile.__init__(self,
name,
backup=backup,
debug=debug,
longListOutputThreshold=None,
doMacroExpansion=doMacroExpansion)
