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_()