def testSolutionFileZippedReadWrite(self):
test=SolutionFile(path.dirname(self.theFile),path.basename(self.theFile))
self.assertEqual(test.readInternalUniform(),"0")
self.assertEqual(test.readBoundary("atmosphere"),"0")
self.assertEqual(test.readDimension(),"0 0 0 0 0 0 0")
test.replaceBoundary("atmosphere",2.3)
self.assertEqual(test.readBoundary("atmosphere"),"2.3")
test.replaceInternal(3.14)
self.assertEqual(test.readInternalUniform(),"3.14")
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 __getitem__(self, key):
self.reread()
if type(key) != str:
raise TypeError(type(key), "of", key, "is not 'str'")
if key not in self.values:
raise KeyError(key)
else:
return SolutionFile(self.name, key)
def testSolutionFileZippedReadWrite(self):
test = SolutionFile(path.dirname(self.theFile),
path.basename(self.theFile))
self.assertEqual(test.readInternalUniform(), "0")
self.assertEqual(test.readBoundary("atmosphere"), "0")
self.assertEqual(test.readDimension(), "0 0 0 0 0 0 0")
test.replaceBoundary("atmosphere", 2.3)
self.assertEqual(test.readBoundary("atmosphere"), "2.3")
test.replaceInternal(3.14)
self.assertEqual(test.readInternalUniform(), "3.14")
[1.27760557e-04, 1.16715642e-04, 0.00000000e+00],
[7.90107847e-05, 1.13855536e-04, 0.00000000e+00],
[1.33227401e-05, 1.51324922e-04, 0.00000000e+00],
[1.41335505e-04, 9.18499088e-05, 0.00000000e+00],
[9.80882076e-05, 1.45416068e-04, 0.00000000e+00]])
i = 0
force = True # force creating folders
generate = False # generate cases
postpro = True # run pv post process
run = False # run simulations
nproc = 30
caseList = []
dire=SolutionDirectory(refCase)
sol=SolutionFile(dire.initialDir(),"Ct")
#activation disk radius (m)
radius = 10e-6
if force:
print('ARRE YOU SUUUUUUUUUUURE ?')
k = 0
if postpro:
for pancackes in range(pancakesCenters.shape[0]):
cp = "cp " + refFile +" " + tmp
subprocess.call(cp, shell=True)
def __init__(self,place,name):
""":param place: directory of the file
:param name: The name of the list file"""
SolutionFile.__init__(self,place,name)
def __init__(self, place, name):
""":param place: directory of the file
:param name: The name of the list file"""
SolutionFile.__init__(self, place, name)
def main():
solver = 'simpleFoam'
case_dir = '.'
n_proc = 4
decompose_method = 'simple'
decompose_coeffs = '(2 2 1)'
log_file = 'log_' + solver
mesh_points = 333329
turb_type = 'laminar'
turb_model = 'no'
ip.set_turbulence_mode(
case_dir, turb_type,
turb_model) #'laminar' or 'RAS', 'none' or 'kEpsilon' or 'kOmega'
d_hyd = 4 * 0.02562 / 0.804201
nu = 0.00001 # SET IN FILE
I = 0.05
Re_range = range(100, 1100, 100)
glob_folders = [
case_dir + '/' + s
for s in ['processor*', '0/cellLevel', '0/pointLevel']
]
glob_files = [case_dir + '/' + s for s in ['log*', 'PyFoam*']]
for Re in Re_range:
print("Re: {}".format(Re))
print("Remove folders from previous run.")
dir = SolutionDirectory(case_dir)
dir.clearResults()
for glob_exp in glob_folders:
ip.rm_folder(glob_exp)
for glob_exp in glob_files:
ip.rm_file(glob_exp)
ip.rm_folder(case_dir + '/postProcessing')
print("Set inlet velocity.")
U_value = Re * nu / d_hyd
U_file = SolutionFile(dir.initialDir(), "U")
U_file.replaceBoundary("inlet", "(0 %f 0)" % (U_value))
ip.delete_line(case_dir + '/0/U', 'PyFoamRemoved')
print("Set magUInf.")
ip.change_line(case_dir + '/system/controlDict', 'magUInf',
' magUInf ' + str(U_value) + '; ')
print("Set turbulent kinetic energy at inlet.")
k_value = 1.5 * (U_value * I)**2
ip.set_turbulence_boundary(case_dir, 'k', ["inlet", "monkey"], k_value)
print("Set turbulent dissipation at inlet.")
epsilon_value = 0.09**(3 / 4) * k_value**(3 / 2) / (0.07 * d_hyd)
ip.set_turbulence_boundary(case_dir, 'epsilon', ["inlet", "monkey"],
epsilon_value)
print("Set specific turbulent dissipation at inlet.")
omega_value = epsilon_value / k_value
ip.set_turbulence_boundary(case_dir, 'omega', ["inlet", "monkey"],
omega_value)
print("Decompose case.")
ip.set_decomposition(case_dir, n_proc, decompose_method,
decompose_coeffs)
ip.bash_command('cd ' + case_dir + ' && decomposePar -force >> ' +
case_dir + '/' + log_file)
print("Renumber mesh for speedup.")
ip.bash_command('cd ' + case_dir + ' && mpirun -np ' + str(n_proc) +
' renumberMesh -overwrite -parallel >> ' + case_dir +
'/' + log_file)
print(turb_type + " simulation using " + turb_model +
" turbulence model on mesh with " + str(mesh_points) +
" mesh points.")
print("Run " + solver + " in parallel.")
ip.bash_command('cd ' + case_dir + ' && mpirun -np ' + str(n_proc) +
' ' + solver + ' -parallel >> ' + case_dir + '/' +
log_file)
print("Reconstruct case.")
ip.bash_command('cd ' + case_dir + ' && reconstructPar >> ' +
case_dir + '/' + log_file)
print("Copy results into results folder.")
ip.make_folder(case_dir + '/Results')
result_string = turb_type + '_' + turb_model + '_turbmodel_' + str(
mesh_points) + '_meshpoints'
ip.make_folder(case_dir + '/Results/forces_' + result_string)
ip.make_folder(case_dir + '/Results/residuals_' + result_string)
ip.copy_files(
case_dir + '/postProcessing/forces/**/*.dat', case_dir +
'/Results/forces_' + result_string + '/Re_' + str(Re) + '.dat', 9)
ip.copy_files(
case_dir + '/postProcessing/residuals/**/*.dat', case_dir +
'/Results/residuals_' + result_string + '/Re_' + str(Re) + '.dat',
2)
from PyFoam.RunDictionary.SolutionFile import SolutionFile
from PyFoam.RunDictionary.SolutionDirectory import SolutionDirectory
solver = "simpleFoam"
case = "pitzDaily"
pCmd = "calcPressureDifference"
mCmd = "calcMassFlow"
dire = SolutionDirectory(case, archive="InletVariation")
dire.clearResults()
dire.addBackup("PyFoamSolve.logfile")
dire.addBackup("PyFoamSolve.analyzed")
dire.addBackup("Pressure.analyzed")
dire.addBackup("MassFlow.analyzed")
sol = SolutionFile(dire.initialDir(), "U")
maximum = 1.
nr = 10
f = dire.makeFile("InflowVariationResults")
for i in range(nr + 1):
# Set the boundary condition at the inlet
val = (maximum * i) / nr
print "Inlet velocity:", val
sol.replaceBoundary("inlet", "(%f 0 0)" % (val))
# Run the solver
run = ConvergenceRunner(BoundingLogAnalyzer(),
argv=[solver, "-case", case],
from PyFoam.RunDictionary.SolutionFile import SolutionFile
from PyFoam.RunDictionary.SolutionDirectory import SolutionDirectory
solver="simpleFoam"
case="pitzDaily"
pCmd="calcPressureDifference"
mCmd="calcMassFlow"
dire=SolutionDirectory(case,archive="InletVariation")
dire.clearResults()
dire.addBackup("PyFoamSolve.logfile")
dire.addBackup("PyFoamSolve.analyzed")
dire.addBackup("Pressure.analyzed")
dire.addBackup("MassFlow.analyzed")
sol=SolutionFile(dire.initialDir(),"U")
maximum=1.
nr=10
f=dire.makeFile("InflowVariationResults")
for i in range(nr+1):
# Set the boundary condition at the inlet
val=(maximum*i)/nr
print "Inlet velocity:",val
sol.replaceBoundary("inlet","(%f 0 0)" %(val))
# Run the solver
run=ConvergenceRunner(BoundingLogAnalyzer(),argv=[solver,"-case",case],silent=True)
run.start()
i += 1
break
print('toto')
#loading sim files
dire = SolutionDirectory(caseName)
dire.clearResults()
# writing CMC
transprortPpties = ParsedParameterFile(
caseName + '/constant/transportProperties')
transprortPpties['Ccmc'][2] = Ccmc
transprortPpties.writeFile()
# writing Ct BC
solCt = SolutionFile(dire.initialDir(), "Ct")
solCt.replaceBoundary("inlet", "%f" % (Cbd))
# writing initial concentrations in the BC<y<BD
c0 = 'funkySetFields -case ' + \
os.path.join(studyPath, caseName) + ' -field Ct -expression "pos().y <= 0.00010447667906605678 ? ' + \
str(Cbc) + ' : ' + str(Cbd) + '" -time 0'
subprocess.call(c0, shell=True)
print(c0)
i += 1
if run:
i = 0
for caseName in caseList:
if i == 2:
from PyFoam.RunDictionary.SolutionFile import SolutionFile from PyFoam.RunDictionary.SolutionDirectory import SolutionDirectory import sys file=sys.argv[1] name=sys.argv[2] bc =sys.argv[3] neu=sys.argv[4] dire=SolutionDirectory(file,archive="TestArchive") sol=SolutionFile(dire.initialDir(),name) print "Old internal",sol.readInternal() sol.replaceInternal(neu) print "New internal",sol.readInternal() sol.purgeFile() print "Reset internal",sol.readInternal() print "Old boundary",sol.readBoundary(bc) sol.replaceBoundary(bc,neu) print "New boundary",sol.readBoundary(bc) sol.purgeFile()
def run(self):
config = ConfigParser.ConfigParser()
files = self.parser.getArgs()
good = config.read(files)
# will work with 2.4
# if len(good)!=len(files):
# print_("Problem while trying to parse files",files)
# print_("Only ",good," could be parsed")
# sys.exit(-1)
benchName = config.get("General", "name")
if self.opts.nameAddition != None:
benchName += "_" + self.opts.nameAddition
if self.opts.foamVersion != None:
benchName += "_v" + self.opts.foamVersion
isParallel = config.getboolean("General", "parallel")
lam = None
if isParallel:
nrCpus = config.getint("General", "nProcs")
machineFile = config.get("General", "machines")
if not path.exists(machineFile):
self.error("Machine file ", machineFile,
"needed for parallel run")
lam = LAMMachine(machineFile, nr=nrCpus)
if lam.cpuNr() > nrCpus:
self.error("Wrong number of CPUs: ", lam.cpuNr())
print_("Running parallel on", lam.cpuNr(), "CPUs")
if config.has_option("General", "casesDirectory"):
casesDirectory = path.expanduser(
config.get("General", "casesDirectory"))
else:
casesDirectory = foamTutorials()
if not path.exists(casesDirectory):
self.error("Directory", casesDirectory,
"needed with the benchmark cases is missing")
else:
print_("Using cases from directory", casesDirectory)
benchCases = []
config.remove_section("General")
for sec in config.sections():
print_("Reading: ", sec)
skipIt = False
skipReason = ""
if config.has_option(sec, "skip"):
skipIt = config.getboolean(sec, "skip")
skipReason = "Switched off in file"
if self.opts.excases != None and not skipIt:
for p in self.opts.excases:
if fnmatch(sec, p):
skipIt = True
skipReason = "Switched off by pattern '" + p + "'"
if self.opts.cases != None:
for p in self.opts.cases:
if fnmatch(sec, p):
skipIt = False
skipReason = ""
if skipIt:
print_("Skipping case ..... Reason:" + skipReason)
continue
sol = config.get(sec, "solver")
cas = config.get(sec, "case")
pre = eval(config.get(sec, "prepare"))
preCon = []
if config.has_option(sec, "preControlDict"):
preCon = eval(config.get(sec, "preControlDict"))
con = eval(config.get(sec, "controlDict"))
bas = config.getfloat(sec, "baseline")
wei = config.getfloat(sec, "weight")
add = []
if config.has_option(sec, "additional"):
add = eval(config.get(sec, "additional"))
print_("Adding: ", add)
util = []
if config.has_option(sec, "utilities"):
util = eval(config.get(sec, "utilities"))
print_("Utilities: ", util)
nr = 99999
if config.has_option(sec, "nr"):
nr = eval(config.get(sec, "nr"))
sp = None
if config.has_option(sec, "blockSplit"):
sp = eval(config.get(sec, "blockSplit"))
toRm = []
if config.has_option(sec, "filesToRemove"):
toRm = eval(config.get(sec, "filesToRemove"))
setInit = []
if config.has_option(sec, "setInitial"):
setInit = eval(config.get(sec, "setInitial"))
parallelOK = False
if config.has_option(sec, "parallelOK"):
parallelOK = config.getboolean(sec, "parallelOK")
deMet = ["metis"]
if config.has_option(sec, "decomposition"):
deMet = config.get(sec, "decomposition").split()
if deMet[0] == "metis":
pass
elif deMet[0] == "simple":
if len(deMet) < 2:
deMet.append(0)
else:
deMet[1] = int(deMet[1])
else:
print_("Unimplemented decomposition method", deMet[0],
"switching to metis")
deMet = ["metis"]
if isParallel == False or parallelOK == True:
if path.exists(path.join(casesDirectory, sol, cas)):
benchCases.append(
(nr, sec, sol, cas, pre, con, preCon, bas, wei, add,
util, sp, toRm, setInit, deMet))
else:
print_("Skipping", sec, "because directory",
path.join(casesDirectory, sol, cas),
"could not be found")
else:
print_("Skipping", sec, "because not parallel")
benchCases.sort()
parallelString = ""
if isParallel:
parallelString = ".cpus=" + str(nrCpus)
resultFile = open(
"Benchmark." + benchName + "." + uname()[1] + parallelString +
".results", "w")
totalSpeedup = 0
minSpeedup = None
maxSpeedup = None
totalWeight = 0
runsOK = 0
currentEstimate = 1.
print_("\nStart Benching\n")
csv = CSVCollection("Benchmark." + benchName + "." + uname()[1] +
parallelString + ".csv")
# csvHeaders=["description","solver","case","caseDir","base",
# "benchmark","machine","arch","cpus","os","version",
# "wallclocktime","cputime","cputimeuser","cputimesystem","maxmemory","cpuusage","speedup"]
for nr, description, solver, case, prepare, control, preControl, base, weight, additional, utilities, split, toRemove, setInit, decomposition in benchCases:
# control.append( ("endTime",-2000) )
print_("Running Benchmark: ", description)
print_("Solver: ", solver)
print_("Case: ", case)
caseName = solver + "_" + case + "_" + benchName + "." + uname(
)[1] + ".case"
print_("Short name: ", caseName)
caseDir = caseName + ".runDir"
csv["description"] = description
csv["solver"] = solver
csv["case"] = case
csv["caseDir"] = caseDir
csv["base"] = base
csv["benchmark"] = benchName
csv["machine"] = uname()[1]
csv["arch"] = uname()[4]
if lam == None:
csv["cpus"] = 1
else:
csv["cpus"] = lam.cpuNr()
csv["os"] = uname()[0]
csv["version"] = uname()[2]
workDir = path.realpath(path.curdir)
orig = SolutionDirectory(path.join(casesDirectory, solver, case),
archive=None,
paraviewLink=False)
for a in additional + utilities:
orig.addToClone(a)
orig.cloneCase(path.join(workDir, caseDir))
if oldApp():
argv = [solver, workDir, caseDir]
else:
argv = [solver, "-case", path.join(workDir, caseDir)]
run = BasicRunner(silent=True,
argv=argv,
logname="BenchRunning",
lam=lam)
runDir = run.getSolutionDirectory()
controlFile = ParameterFile(runDir.controlDict())
for name, value in preControl:
print_("Setting parameter", name, "to", value,
"in controlDict")
controlFile.replaceParameter(name, value)
for rm in toRemove:
fn = path.join(caseDir, rm)
print_("Removing file", fn)
remove(fn)
for field, bc, val in setInit:
print_("Setting", field, "on", bc, "to", val)
SolutionFile(runDir.initialDir(),
field).replaceBoundary(bc, val)
oldDeltaT = controlFile.replaceParameter("deltaT", 0)
for u in utilities:
print_("Building utility ", u)
execute("wmake 2>&1 >%s %s" % (path.join(
caseDir, "BenchCompile." + u), path.join(caseDir, u)))
print_("Preparing the case: ")
if lam != None:
prepare = prepare + [("decomposePar", "")]
if decomposition[0] == "metis":
lam.writeMetis(
SolutionDirectory(path.join(workDir, caseDir)))
elif decomposition[0] == "simple":
lam.writeSimple(
SolutionDirectory(path.join(workDir, caseDir)),
decomposition[1])
if split:
print_("Splitting the mesh:", split)
bm = BlockMesh(runDir.blockMesh())
bm.refineMesh(split)
for pre, post in prepare:
print_("Doing ", pre, " ....")
post = post.replace("%case%", caseDir)
if oldApp():
args = string.split("%s %s %s %s" %
(pre, workDir, caseDir, post))
else:
args = string.split(
"%s -case %s %s" %
(pre, path.join(workDir, caseDir), post))
util = BasicRunner(silent=True,
argv=args,
logname="BenchPrepare_" + pre)
util.start()
controlFile.replaceParameter("deltaT", oldDeltaT)
# control.append(("endTime",-1000))
for name, value in control:
print_("Setting parameter", name, "to", value,
"in controlDict")
controlFile.replaceParameter(name, value)
print_("Starting at ", asctime(localtime(time())))
print_(
" Baseline is %f, estimated speedup %f -> estimated end at %s "
% (base, currentEstimate,
asctime(localtime(time() + base / currentEstimate))))
print_("Running the case ....")
run.start()
speedup = None
cpuUsage = 0
speedupOut = -1
try:
speedup = base / run.run.wallTime()
cpuUsage = 100. * run.run.cpuTime() / run.run.wallTime()
except ZeroDivisionError:
print_("Division by Zero: ", run.run.wallTime())
if not run.runOK():
print_("\nWARNING!!!!")
print_(
"Run had a problem, not using the results. Check the log\n"
)
speedup = None
if speedup != None:
speedupOut = speedup
totalSpeedup += speedup * weight
totalWeight += weight
runsOK += 1
if maxSpeedup == None:
maxSpeedup = speedup
elif speedup > maxSpeedup:
maxSpeedup = speedup
if minSpeedup == None:
minSpeedup = speedup
elif speedup < minSpeedup:
minSpeedup = speedup
print_("Wall clock: ", run.run.wallTime())
print_("Speedup: ", speedup, " (Baseline: ", base, ")")
print_("CPU Time: ", run.run.cpuTime())
print_("CPU Time User: "******"CPU Time System: ", run.run.cpuSystemTime())
print_("Memory: ", run.run.usedMemory())
print_("CPU Usage: %6.2f%%" % (cpuUsage))
csv["wallclocktime"] = run.run.wallTime()
csv["cputime"] = run.run.cpuTime()
csv["cputimeuser"] = run.run.cpuUserTime()
csv["cputimesystem"] = run.run.cpuSystemTime()
csv["maxmemory"] = run.run.usedMemory()
csv["cpuusage"] = cpuUsage
if speedup != None:
csv["speedup"] = speedup
else:
csv["speedup"] = "##"
csv.write()
resultFile.write(
"Case %s WallTime %g CPUTime %g UserTime %g SystemTime %g Memory %g MB Speedup %g\n"
% (caseName, run.run.wallTime(), run.run.cpuTime(),
run.run.cpuUserTime(), run.run.cpuSystemTime(),
run.run.usedMemory(), speedupOut))
resultFile.flush()
if speedup != None:
currentEstimate = totalSpeedup / totalWeight
if self.opts.removeCases:
print_("Clearing case", end=" ")
if speedup == None:
print_("not ... because it failed")
else:
print_("completely")
rmtree(caseDir, ignore_errors=True)
print_()
print_()
