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 write_read_turbulence_coefficients(case_number, case_i_dir, turb_coeffs,
turb_coeffs_values, delta_turb_coeffs):
if case_number == 1:
turb = ParsedParameterFile(case_i_dir +
"/constant/turbulenceProperties")
for k in turb_coeffs:
turb_coeffs_values[k].append(turb['RAS']['kOmegaSSTCoeffs'][k])
print "\nTurbulence coefficients:"
for l in turb_coeffs:
print l + ": %.4f" % (turb_coeffs_values[l][0])
else:
turb = ParsedParameterFile(case_i_dir +
"/constant/turbulenceProperties")
for m in turb_coeffs:
turb['RAS']['kOmegaSSTCoeffs'][m] += delta_turb_coeffs['delta_' +
m]
turb.writeFile()
for n in turb_coeffs:
turb_coeffs_values[n].append(turb['RAS']['kOmegaSSTCoeffs'][n])
print "\nTurbulence coefficients:"
for o in turb_coeffs:
print o + ": %.4f" % (turb_coeffs_values[o][case_number - 1])
return turb_coeffs_values
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 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 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 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 main(args):
# 0 - reading input
cwd = os.getcwd()
os.chdir(args.target)
if len(glob.glob("*.map")) > 1:
print "error: more then a single map file in the directory, please delete all except one"
raise SystemExit
mapFileName = glob.glob("*.map")[0]
remove_extra_spaces(mapFileName)
from pdb import set_trace
#set_trace()
# 0.5 creating z0 dummy file
os.system("cp -r 0/p 0/z0")
z0Dict = ParsedParameterFile("0/z0")
z0Dict.header["object"] = "z0"
for b in z0Dict["boundaryField"]:
print b
if type(b) is str:
if b.find("terrain") > -1 or b.find("ground") > -1:
print "found terrain/ground in z0 at patch " + b
z0Dict["boundaryField"][b]["value"] = "uniform 0"
z0Dict["boundaryField"][b]["type"] = "fixedValue"
z0Dict["dimensions"] = "[ 0 1 0 0 0 0 0]"
z0Dict.writeFile()
# 1 - running roughnessToFoam.C
callString = "( echo %s; echo %d; echo %d; echo %d; echo %d; echo %d; echo %d) | roughnessToFoam" % (
mapFileName, args.offsetX, args.offsetY, args.point_ax, args.point_ay,
args.point_bx, args.point_by)
os.system(callString)
# 2 - reading modified z0 file - made with roughnessToFoam.C
z0Dict = ParsedParameterFile("0/z0")
for b in z0Dict["boundaryField"]:
if type(b) is str:
if b.find("terrain") > -1:
# TODO - save each different *terrain*'s z0 and place in matching nut *terrain*. at the moment - only one patch with "terrain" in it is expected, and one with "ground".
z0Terrain = z0Dict["boundaryField"][b]["value"]
print "taken *terrain* z0 from %s" % b
if b.find("ground") > -1:
z0Ground = z0Dict["boundaryField"][b]["value"]
print "taken *ground* z0 from %s" % b
# 3 - writing z0 into nut file
nutDict = ParsedParameterFile("0/nut")
for b in nutDict["boundaryField"]:
if type(b) is str:
for c in nutDict["boundaryField"][b]:
if "z0" in c:
if b.find("terrain") > -1:
nutDict["boundaryField"][b]["z0"] = z0Terrain
if b.find("ground") > -1:
nutDict["boundaryField"][b]["z0"] = 0
nutDict["boundaryField"][b]["z0"] = z0Ground
nutDict.writeFile()
os.chdir(cwd)
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 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 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 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 testReadTutorial(self):
if foamVersionNumber()>=(2,):
# there is no appropriate volSymmTensorField-file in 2.x
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 updateFieldFiles(self, timedir, fields, currtime):
#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)
filename2 = '%s/system/changeDictionaryPetroSym' % self.currentFolder
fieldData2 = []
if os.path.isfile(filename2):
fieldData2 = ParsedParameterFile(filename2, createZipped=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:
if boundaries[ipatch]['type'] == 'empty':
patchDict['type'] = 'empty'
else:
patchDict['type'] = 'zeroGradient'
else:
patchDict['type'] = 'calculated'
if fieldData2 == []:
fieldData['boundaryField'][ipatch] = patchDict
else:
fieldData2['dictionaryReplacement'][ifield][
'boundaryField'][ipatch] = patchDict
# poner el campo interno uniforme en cero
if types[ifield] == 'scalar':
if fieldData2 == []:
fieldData['internalField'] = 'uniform 0'
else:
fieldData2['dictionaryReplacement'][ifield][
'internalField'] = 'uniform 0'
elif types[ifield] == 'vector':
if fieldData2 == []:
fieldData['internalField'] = 'uniform (0 0 0)'
else:
fieldData2['dictionaryReplacement'][ifield][
'internalField'] = 'uniform (0 0 0)'
fieldData.writeFile()
if fieldData2 != []:
fieldData2.writeFile()
return
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 create_boundary_conditions_dict(self, work, wind_dict, params):
#--------------------------------------------------------------------------------------
# changing inlet profile - - - - according to Martinez 2010
#--------------------------------------------------------------------------------------
phi = params['phi']
i = params['i']
SHM = wind_dict['SHMParams']
kEpsParams = wind_dict['kEpsParams']
k = kEpsParams['k'] # von karman constant
z0 = wind_dict["caseTypes"]["windRose"]["windDir"][i][
2] # TODO: calculated per wind direction using roughness2foam
us = wind_dict["caseTypes"]["windRose"]["windDir"][i][4]
Href = SHM['domainSize']['domZ']
TKE = us**2 * wind_dict["caseTypes"]["windRose"]["windDir"][i][3]
Cmu = us / TKE**2
# change inlet profile
z_min = wind_dict['SHMParams']['domainSize']['z_min']
Uref = Utop = us / k * log((Href - z_min) / z0)
# 1: changing ABLConditions
bmName = path.join(work.initialDir(), "include", "ABLConditions")
template = TemplateFile(bmName + ".template")
template.writeToFile(
bmName, {
'us': us,
'Uref': Uref,
'Href': Href,
'z0': z0,
'xDirection': sin(phi),
'yDirection': cos(phi)
})
# 2: changing initialConditions
bmName = path.join(work.initialDir(), "include", "initialConditions")
template = TemplateFile(bmName + ".template")
template.writeToFile(bmName, {'TKE': TKE})
# 3: changing initial and boundary conditions for z0
# changing z0 in nut, inside nutkAtmRoughWallFunction - for rectanguleDomainSTL = 0 for both terrain and ground patches
nutFile = ParsedParameterFile(path.join(work.initialDir(), "nut"))
if SHM["rectanguleDomainSTL"]:
nutFile["boundaryField"]["ground"]["z0"].setUniform(z0)
nutFile["boundaryField"]["terrain_.*"]["z0"].setUniform(z0)
else:
nutFile["boundaryField"]["ground"]["z0"].setUniform(
SHM["ground_z0"])
nutFile["boundaryField"]["terrain_.*"]["z0"].setUniform(
SHM["terrain_z0"])
nutFile.writeFile()
# 3: changing transport properties
transportFile = ParsedParameterFile(
path.join(work.constantDir(), 'transportProperties'))
transportFile['nu'] = "nu [0 2 -1 0 0 0 0] " + str(
wind_dict['simParams']['nu'])
transportFile.writeFile()
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 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):
materialsABMUI.__init__(self)
for key in emptys.keys():
if key != 'name':
self.__getattribute__(key).setValidator(QtGui.QDoubleValidator())
filename = '%s/caseDicts/materialProperties.incompressible'%os.path.dirname(os.path.realpath(__file__)) #Path de python
from os.path import expanduser
self.home = expanduser('~')
filename2 = '%s/.config/petroSym/materialProperties.incompressible'%self.home #Path en home
if not os.path.isfile(filename2) or (os.path.isfile(filename2) and os.path.getsize(filename2) == 0): #Si no existe, o existe y esta vacio
command = 'mkdir -p %s/.config/petroSym/'%self.home #-p por si ya existe el directorio
os.system(command)
command = 'cp %s %s/.config/petroSym/'%(filename,self.home) #copio el archivo
os.system(command)
parsedData = ParsedParameterFile(filename2,createZipped=False)
self.defaults = parsedData['defaults']
self.userLibrary = parsedData['userLibrary']
for key in self.defaults.keys():
self.list_default.addItem(key)
for key in self.userLibrary.keys():
self.list_user.addItem(key)
self.list_default.item(0).setSelected(True)
self.changeSelectionDefault()
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 __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 __iter__(self):
self.reread()
for key in self.values:
if self.yieldParsedFiles:
yield ParsedParameterFile(path.join(self.name, key))
else:
yield SolutionFile(self.name, key)
def testReadNoMacroExpansion(self):
kFile = ParsedParameterFile(path.join(self.dest, "k"))
self.assertEqual(str(kFile["internalField"]), "uniform $turbulentKE")
self.assertEqual(kFile["boundaryField"]["lowerWall"]["value"],
"$internalField")
self.assertEqual(kFile["boundaryField"]["motorBikeGroup"]["value"],
"$internalField")
def saveUserLibrary(self):
filename = 'caseDicts/materialProperties.incompressible'
parsedData = ParsedParameterFile(filename, createZipped=False)
parsedData['userLibrary'] = self.userLibrary
parsedData.writeFile()
return
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'] = '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 getParametersFromFile(self):
"""Get Parameters from the file created by PrepareCase"""
fName=path.join(self.name,"PyFoamPrepareCaseParameters")
if path.exists(fName):
return ParsedParameterFile(fName,noHeader=True).content
else:
return {}
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 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 addFunctionObjects(self, templateFile):
"""Add entries for libraries and functionObjects to the controlDict
(if they don't exist
@param templateFile: file withe the data that should be added
"""
tf = ParsedParameterFile(templateFile)
cd = self.controlDict()
touchedCD = False
if "libs" in tf:
touchedCD = True
if not "libs" in cd:
cd["libs"] = []
for l in tf["libs"]:
if l in cd["libs"]:
self.warn(l, "already in 'libs' in the controlDict")
else:
cd["libs"].append(l)
if "functions" in tf:
touchedCD = True
if not "functions" in cd:
cd["functions"] = {}
for k, v in iteritems(tf["functions"]):
if k in cd["functions"]:
self.warn("Overwriting function object", k)
cd["functions"][k] = v
if touchedCD:
cd.writeFile()
def __init__(self, casePath, stlSolid, nprocs=None, baseCellSize=0.25, parserArgs=None):
self.casePath = casePath
self.stlSolid = stlSolid
self.procsUtil = Utilities.parallelUtilities(nprocs)
self.baseCellSize = baseCellSize
if self.procsUtil.procs > 1:
self.parallel = True
self.nprocs = self.procsUtil.procs
else:
self.parallel = False
self.nprocs = 1
## Load in blockMeshDict
self.blockMeshDict = ParsedParameterFile(os.path.join(casePath,'constant','polyMesh','blockMeshDict'))
self.snappyHexMeshDict = ParsedParameterFile(os.path.join(casePath,'system','snappyHexMeshDict'))
self.cfMeshDict = ParsedParameterFile(os.path.join(casePath,'system','meshDict'))
self.decomposeParDict = ParsedParameterFile(os.path.join(casePath,'system','decomposeParDict'))
