def __init__(self): BoundingLogAnalyzer.__init__(self) self.addAnalyzer("deltaT", SimpleLineAnalyzer("deltaT", "^deltaT = (.+)$")) self.addAnalyzer( "LiquidPhase", SimpleLineAnalyzer( "liquid", "^Liquid phase volume fraction = (.+) Min\((.+)\) = (.+) Max\(.+\) = (.+)$", idNr=2))
def Optimisationrun(self): #run simpleFoam run=ConvergenceRunner(BoundingLogAnalyzer(),argv=[self.solver1,"-case",self.case_path],silent=True) run.start() subprocess.call(['pyFoamCopyLastToFirst.py',self.case_path, self.case_path]) subprocess.call(['pyFoamClearCase.py', self.case_path]) subprocess.call(['rm', self.case_path+'0/cellLevel'])
def run(self): cName = self.parser.casePath() self.checkCase(cName) self.processPlotLineOptions(autoPath=cName) sol = SolutionDirectory(cName, archive=None) lam = self.getParallel(sol) self.clearCase( SolutionDirectory(cName, archive=None, parallel=lam is not None)) self.setLogname() self.checkAndCommit(sol) run = ConvergenceRunner(BoundingLogAnalyzer( progress=self.opts.progress, doFiles=self.opts.writeFiles, singleFile=self.opts.singleDataFilesOnly, doTimelines=True), silent=self.opts.progress or self.opts.silent, argv=self.parser.getArgs(), restart=self.opts.restart, server=self.opts.server, logname=self.opts.logname, compressLog=self.opts.compress, lam=lam, logTail=self.opts.logTail, noLog=self.opts.noLog, remark=self.opts.remark, parameters=self.getRunParameters(), echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.createPlots(customRegexp=self.lines_, writeFiles=self.opts.writeFiles) if self.cursesWindow: self.cursesWindow.setAnalyzer(run.analyzer) self.cursesWindow.setRunner(run) run.analyzer.addTimeListener(self.cursesWindow) self.addSafeTrigger(run, sol) self.addWriteAllTrigger(run, sol) self.addToCaseLog(cName, "Starting") run.start() self.addToCaseLog(cName, "Ending") self.setData(run.data) self.reportUsage(run) self.reportRunnerData(run) return run.data
def run_solver(self): run_command = self.solver if self.np != 1: np_substring = "" if self.hpc else f"-np {self.np} " run_command = f"mpiexec {np_substring}{self.solver} -parallel" runner = ConvergenceRunner( BoundingLogAnalyzer(), argv=[run_command, "-case", self.dire.name], silent=True, logname=self.solver, ) runner.start() if not runner.data["OK"]: raise RuntimeError("Failed running solver")
def run(self): origPath = self.parser.getArgs()[0] parameterFile = self.parser.getArgs()[1] self.addLocalConfig(origPath) self.checkCase(origPath) nrModes=(1 if self.opts.inplaceExecution else 0) + \ (1 if self.opts.oneClonedCase else 0) + \ (1 if self.opts.listVariations else 0) + \ (1 if self.opts.everyVariantOneCase else 0) if nrModes == 0: self.error( "Specify one of the modes --list-variations, --inplace-execution, --one-cloned-case-execution or --every-variant-one-case-execution" ) elif nrModes > 1: self.error( "The modes --list-variations, --inplace-execution, --one-cloned-case-execution or --every-variant-one-case-execution are mutual exclusive" ) if self.opts.noExecuteSolver: if not self.opts.everyVariantOneCase and self.opts.singleVariation == None and not self.opts.listVariations: self.error( "--no-execute-solver only works with --every-variant-one-case-execution" ) if not self.opts.clonedCasePrefix: self.opts.clonedCasePrefix = path.basename(parameterFile) if not self.opts.clonedCasePostfix: self.opts.clonedCasePostfix = "" else: self.opts.clonedCasePostfix = "." + self.opts.clonedCasePostfix if not self.opts.cloneToDirectory: self.opts.cloneToDirectory = path.dirname(path.abspath(origPath)) if not self.opts.database: self.opts.database = parameterFile + ".database" variationData = ParsedParameterFile( parameterFile, noHeader=True, noVectorOrTensor=True).getValueDict() if not "values" in variationData: self.error("Entry 'values' (dictionary) needed in", parameterFile) if not "solver" in variationData["values"]: self.error("Entry 'solver' (list or string) needed in 'values' in", parameterFile) fixed = {} defaults = {} varied = [] nrVariations = 1 for k in variationData["values"]: v = variationData["values"][k] if type(v) != list: self.error("Entry", k, "is not a list") if len(v) == 1: fixed[k] = v[0] elif len(v) > 1: varied.append((k, v)) nrVariations *= len(v) else: self.warning("Entry", k, "is empty") if "defaults" in variationData: defaults = variationData["defaults"] if len(varied) == 0: self.error("No parameters to vary") self.printPhase(nrVariations, "variations with", len(varied), "parameters") def makeVariations(vList): name, vals = vList[0] if len(vList) > 1: var = makeVariations(vList[1:]) variation = [] for orig in var: for v in vals: d = orig.copy() if isinstance(v, (dict, DictProxy)): d.update(v) else: d[name] = v variation.append(d) return variation else: return [ v if isinstance(v, (dict, DictProxy)) else { name: v } for v in vals ] variations = [dict(defaults, **d) for d in makeVariations(varied)] self["variations"] = variations self["fixed"] = fixed if self.opts.startVariation != None: start = self.opts.startVariation else: start = 0 if self.opts.endVariation != None: end = self.opts.endVariation if end >= len(variations): end = len(variations) - 1 else: end = len(variations) - 1 if self.opts.singleVariation != None: if self.opts.startVariation or self.opts.endVariation: self.error( "--single-variation not possible with --end-variation-number or --start-variation-number" ) if self.opts.singleVariation < 0: self.error("--single-variation must be greater or equal to 0") if self.opts.singleVariation >= len(variations): self.error("Only", len(variations)) start = self.opts.singleVariation end = self.opts.singleVariation if end < start: self.error("Start value", start, "bigger than end value", end) if self.opts.listVariations: self.printPhase("Listing variations") for i in range(start, end + 1): print_("Variation", i, ":", variations[i]) return if not hasDatabase or self.opts.noDatabaseWrite: if path.exists(self.opts.database) and self.opts.createDatabase: self.error("database-file", self.opts.database, "exists already.") elif not path.exists( self.opts.database ) and not self.opts.createDatabase and not self.opts.autoCreateDatabase: self.error("database-file", self.opts.database, "does not exist") createDatabase = self.opts.createDatabase if self.opts.autoCreateDatabase and not path.exists( self.opts.database): createDatabase = True if not hasDatabase or self.opts.noDatabaseWrite: db = None else: db = RunDatabase(self.opts.database, create=createDatabase, verbose=self.opts.verbose) origCase = SolutionDirectory(origPath, archive=None) if self.opts.oneClonedCase: self.printPhase("Cloning work case") workCase = origCase.cloneCase( path.join( self.opts.cloneToDirectory, self.opts.clonedCasePrefix + "_" + path.basename(origPath)) + self.opts.clonedCasePostfix) self.printPhase("Starting actual variations") for i in range(start, end + 1): self.printPhase("Variation", i, "of [", start, ",", end, "]") usedVals = variations[i].copy() usedVals.update(fixed) self.prepareHooks() clone = False if self.opts.inplaceExecution: workCase = origCase elif self.opts.oneClonedCase: pass else: self.printPhase("Cloning work case") workCase = origCase.cloneCase( path.join( self.opts.cloneToDirectory, self.opts.clonedCasePrefix + "_" + ("%05d" % i) + "_" + path.basename(origPath)) + self.opts.clonedCasePostfix) self.processPlotLineOptions(autoPath=workCase.name) self.printPhase("Setting up the case") self.prepare(workCase, overrideParameters=usedVals) if self.opts.noExecuteSolver: self.printPhase("Not executing the solver") continue if self.opts.oneClonedCase or self.opts.inplaceExecution: self.setLogname(self.opts.clonedCasePrefix + ("_%05d_" % i) + usedVals["solver"], useApplication=False, force=True) else: self.setLogname(self.opts.clonedCasePrefix + "_" + usedVals["solver"], useApplication=False, force=True) lam = self.getParallel(workCase) allLines().clear() allPlots().clear() resetCustomCounter() run = AnalyzedRunner( BoundingLogAnalyzer(progress=self.opts.progress, doFiles=self.opts.writeFiles, singleFile=self.opts.singleDataFilesOnly, doTimelines=True), silent=self.opts.progress or self.opts.silent, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, argv=[usedVals["solver"], "-case", workCase.name], server=self.opts.server, lam=lam, logname=self.opts.logname, compressLog=self.opts.compress, logTail=self.opts.logTail, noLog=self.opts.noLog, remark=self.opts.remark, parameters=usedVals, echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.createPlots(customRegexp=self.lines_, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, writeFiles=self.opts.writeFiles) self.runPreHooks() self.printPhase("Running") run.start() self.printPhase("Getting data") self["run%05d" % i] = run.data if db: db.add(run.data) self.runPostHooks() self.reportUsage(run) self.reportRunnerData(run) self.printPhase("Ending variation")
def __init__(self): BoundingLogAnalyzer.__init__(self) self.addAnalyzer("deltaT",SimpleLineAnalyzer("deltaT","^deltaT = (.+)$")) self.addAnalyzer("LiquidPhase",SimpleLineAnalyzer("liquid","^Liquid phase volume fraction = (.+) Min\((.+)\) = (.+) Max\(.+\) = (.+)$",idNr=2))
def run(self): if self.opts.keeppseudo and (not self.opts.regions and self.opts.region == None): warning( "Option --keep-pseudocases only makes sense for multi-region-cases" ) if self.opts.region: regionNames = self.opts.region else: regionNames = [None] regions = None casePath = self.parser.casePath() self.checkCase(casePath) # self.addLocalConfig(casePath) self.addToCaseLog(casePath, "Starting") self.prepareHooks() if self.opts.regions or self.opts.region != None: print_("Building Pseudocases") sol = SolutionDirectory(casePath, archive=None) regions = RegionCases(sol, clean=True) if self.opts.regions: regionNames = sol.getRegions() self.processPlotLineOptions(autoPath=casePath) lam = self.getParallel(SolutionDirectory(casePath, archive=None)) self.clearCase(SolutionDirectory(casePath, archive=None, parallel=lam is not None), runParallel=lam is not None) self.checkAndCommit(SolutionDirectory(casePath, archive=None)) self.initBlink() for theRegion in regionNames: args = self.buildRegionArgv(casePath, theRegion) self.setLogname() run = AnalyzedRunner(BoundingLogAnalyzer( progress=self.opts.progress, doFiles=self.opts.writeFiles, singleFile=self.opts.singleDataFilesOnly, doTimelines=True), silent=self.opts.progress or self.opts.silent, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, argv=self.replaceAutoInArgs(args), server=self.opts.server, lam=lam, restart=self.opts.restart, logname=self.opts.logname, compressLog=self.opts.compress, logTail=self.opts.logTail, noLog=self.opts.noLog, remark=self.opts.remark, parameters=self.getRunParameters(), echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.createPlots(customRegexp=self.lines_, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, writeFiles=self.opts.writeFiles) if self.cursesWindow: self.cursesWindow.setAnalyzer(run.analyzer) self.cursesWindow.setRunner(run) run.analyzer.addTimeListener(self.cursesWindow) self.addWriteAllTrigger(run, SolutionDirectory(casePath, archive=None)) self.addLibFunctionTrigger( run, SolutionDirectory(casePath, archive=None)) self.runPreHooks() if self.blink1: run.addTicker(lambda: self.blink1.ticToc()) run.start() if len(regionNames) > 1: self.setData({theRegion: run.data}) else: self.setData(run.data) self.runPostHooks() self.reportUsage(run) self.reportRunnerData(run) if theRegion != None: print_("Syncing into master case") regions.resync(theRegion) self.stopBlink() if regions != None: if not self.opts.keeppseudo: print_("Removing pseudo-regions") regions.cleanAll() else: for r in sol.getRegions(): if r not in regionNames: regions.clean(r) self.addToCaseLog(casePath, "Ended")
def __init__(self): BoundingLogAnalyzer.__init__(self) self.addAnalyzer("Compact",CompactLineAnalyzer())
def __init__(self): BoundingLogAnalyzer.__init__(self) self.addAnalyzer("Compact", CompactLineAnalyzer())
def run(self): casePath = self.parser.casePath() self.checkCase(casePath) # self.addLocalConfig(casePath) self.addToCaseLog(casePath, "Starting") self.prepareHooks() self.processPlotLineOptions(autoPath=casePath) lam = self.getParallel(SolutionDirectory(casePath, archive=None)) isParallel = lam is not None self.lastWrittenTime = None sol = SolutionDirectory(casePath, archive=None, parallel=isParallel) ctrlDict = ParameterFile(sol.controlDict(), backup=False) if ctrlDict.readParameter("startFrom") != "latestTime": self.error( "In", casePath, "the value of 'startFrom' is not 'latestTime' (required for this script)" ) args = self.replaceAutoInArgs(self.parser.getArgs()) def checkRestart(data=None): lastTimeName = sol.getLast() lastTime = float(lastTimeName) ctrlDict = ParameterFile(sol.controlDict(), backup=False) endTime = float(ctrlDict.readParameter("endTime")) if abs(endTime - lastTime) / endTime < 1e-5: return "Reached endTime {}".format(endTime) logfile = calcLogname(self.opts.logname, args) isRestart, restartnr, restartName, lastlog = findRestartFiles( logfile, sol) # TODO: look into the logfile if self.lastWrittenTime is not None: if self.lastWrittenTime == lastTimeName: return "Last restart didn't improve on {}. Further restarts make no sense".format( lastTime) self.lastWrittenTime = lastTimeName if data: if "stepNr" in data and data["stepNr"] < self.opts.minimumSteps: return "Only {} steps done while {} are required".format( data["stepNr"], self.opts.minimumSteps) redo = True reason = checkRestart() if reason is not None: self.warning("Not starting:", reason) redo = False self.checkAndCommit(sol) self.initBlink() startNr = 0 self.setLogname() while redo: startNr += 1 print_() print_("Starting restart nr", startNr, "on case", casePath) print_() self.addToCaseLog(casePath, "Restart nr", startNr, "started") run = AnalyzedRunner(BoundingLogAnalyzer( progress=self.opts.progress, doFiles=self.opts.writeFiles, singleFile=self.opts.singleDataFilesOnly, doTimelines=True), silent=self.opts.progress or self.opts.silent, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, argv=args, server=self.opts.server, lam=lam, logname=self.opts.logname, compressLog=self.opts.compress, logTail=self.opts.logTail, noLog=self.opts.noLog, remark=self.opts.remark, parameters=self.getRunParameters(), echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.createPlots(customRegexp=self.lines_, splitThres=self.opts.splitDataPointsThreshold if self.opts.doSplitDataPoints else None, writeFiles=self.opts.writeFiles) if self.cursesWindow: self.cursesWindow.setAnalyzer(run.analyzer) self.cursesWindow.setRunner(run) run.analyzer.addTimeListener(self.cursesWindow) self.addWriteAllTrigger(run, SolutionDirectory(casePath, archive=None)) self.addLibFunctionTrigger( run, SolutionDirectory(casePath, archive=None)) self.runPreHooks() if self.blink1: run.addTicker(lambda: self.blink1.ticToc()) run.start() if run.data["keyboardInterrupt"]: print_() self.warning("Not restarting because of keyboard interrupt") redo = False self.setData({startNr: run.data}) self.runPostHooks() self.reportUsage(run) self.reportRunnerData(run) self.addToCaseLog(casePath, "Restart nr", startNr, "ended") reason = checkRestart(data=run.data) if reason is not None: print_() self.warning("Not starting:", reason) self.addToCaseLog(casePath, "Stopping because of", reason) redo = False if startNr >= self.opts.maximumRestarts: print_() self.warning("Maximum number", self.opts.maximumRestarts, "restarts reached") self.addToCaseLog(casePath, "Stopping because maximum number", self.opts.maximumRestarts, "of restarts reached") redo = False self.stopBlink() self.addToCaseLog(casePath, "Ended") print_() print_("Ended after", startNr, "restarts") print_()
def run(self): fName=self.parser.getArgs()[0] dom=parse(fName) doc=dom.documentElement if doc.tagName!='comparator': error("Wrong root-element",doc.tagName,"Expected: 'comparator'") self.data=ComparatorData(doc) purge=False if doc.hasAttribute('purge'): purge=eval(doc.getAttribute('purge')) if self.opts.purge: purge=self.opts.purge if self.opts.nopurge: purge=False steady=False if doc.hasAttribute('steady'): steady=eval(doc.getAttribute('steady')) if self.opts.steady: purge=self.opts.steady print_(" Parameters read OK ") print_() aLog=open(self.data.id+".overview","w") csv=CSVCollection(self.data.id+".csv") rDir=self.data.id+".results" rmtree(rDir) mkdir(rDir) calculated=0 format="%%0%dd" % len(str(len(self.data))) for i in range(len(self.data)): runID=(format % i) print_(runID,end=" ",file=aLog) csv["ID"]=runID use,para=self.data[i] para["template"]=self.data.template para["extension"]=self.data.extension para["id"]=self.data.id if use: calculated+=1 print_("Executing Variation",i+1,"of",len(self.data),end=" ") if calculated!=i+1: print_("(",calculated,"actually calculated)") else: print_() print_("Parameters:",end=" ") for k,v in iteritems(para): print_("%s='%s' " % (k,v),end=" ") if v.find(" ")>=0 or v.find("\t")>=0: v="'"+v+"'" print_(v,end=" ",file=aLog) csv[k]=v print_() if not use: print_("Skipping because not all conditions are satisfied") csv.clear() print_() continue cName=("%s."+format) % (self.data.id, i) log=open(cName+".log","w") para["case"]=cName print_("Case-directory:",cName) para["results"]=path.join(rDir,runID) print_("Results directory:",para["results"]) mkdir(para["results"]) if path.exists(cName): if self.opts.removeOld: print_(" Removing old case-directory") rmtree(cName) else: error("Case-directory",cName,"exists") print_(" copying template") out=copytree(self.data.template,cName) print_("---- Copying",file=log) for l in out: print_(l,end=" ",file=log) print_(" preparing") ok,erg=self.data.prep.execute(para,log) print_(ok,end=" ",file=aLog) csv["prepare OK"]=ok for i in range(len(erg)): print_(erg[i],end=" ",file=aLog) csv["Prepare %02d" % i]=erg[i] aLog.flush() if self.opts.test: print_(" Skipping execution") else: print_(" running the solver") sys.stdout.flush() if steady: runnerClass=ConvergenceRunner else: runnerClass=AnalyzedRunner run=runnerClass(BoundingLogAnalyzer(doTimelines=True,progress=True), argv=[self.data.solver,".",cName], silent=True, lam=Command.parallel, server=self.opts.server) run.start() ok=run.runOK() if ok: print_(" executed OK") else: print_(" fatal error") for aName in run.listAnalyzers(): a=run.getAnalyzer(aName) if 'titles' in dir(a): for tit in a.lines.getValueNames(): t,v=a.getTimeline(tit) if len(v)>0: para["result_"+aName+"_"+tit]=v[-1] print_(run.runOK(),run.lastTime(),run.run.wallTime(),end=" ",file=aLog) csv["Run OK"]=run.runOK() csv["End Time"]=run.lastTime() csv["Wall Time"]=run.run.wallTime() csv["Wall Time (Foam)"]=run.totalClockTime() csv["CPU Time"]=run.totalCpuTime() csv["Wall Time First Step"]=run.firstClockTime() csv["CPU Time First Step"]=run.firstCpuTime() para["endTime"]=run.lastTime() para["runlog"]=run.logFile if self.opts.showDict: print_(para) print_(" evaluating results") ok,erg=self.data.post.execute(para,log) if Command.parallel!=None: print_(" Stoping LAM") Command.parallel.stop() Command.parallel=None if ok: print_(" Evaluation OK",end=" ") else: print_(" Evaluation failed",end=" ") if len(erg)>0: print_(":",erg,end=" ") print_() print_(ok,end=" ",file=aLog) for i in range(len(erg)): print_(erg[i],end=" ",file=aLog) csv["Post %02d" % i]=erg[i] if purge: print_(" removing the case-directory") out=rmtree(cName) print_("---- Removing",file=log) for l in out: print_(l,end=" ",file=log) log.close() print_() print_(file=log) aLog.flush() csv.write() aLog.close()
#! /usr/bin/env python description = """\ Analyzes a Log written by foamJob. Needs the name of the Logfile to be analyzed the data is being written to a directory that has the same name with _analyzed appended """ from PyFoam.Basics.FoamOptionParser import FoamOptionParser parse = FoamOptionParser(description=description, usage="%prog [options] <logfile>", interspersed=True) parse.parse(nr=1) from PyFoam.LogAnalysis.BoundingLogAnalyzer import BoundingLogAnalyzer from PyFoam.LogAnalysis.LogAnalyzerApplication import LogAnalyzerApplication analyze = LogAnalyzerApplication(BoundingLogAnalyzer()) analyze.run(pfad=parse.getArgs()[0])
def __init__(self, fname, smallestFreq=0., persist=None, splitThres=2048, plotLinear=True, plotCont=True, plotBound=True, plotIterations=False, plotCourant=False, plotExecution=False, plotDeltaT=False, hardcopy=False, hardcopyFormat="png", hardcopyPrefix=None, hardcopyTerminalOptions=None, customRegexp=None, writeFiles=False, raiseit=False, progress=False, start=None, end=None, singleFile=False, writePickled=True, plottingImplementation=None, gnuplotTerminal=None, adaptFrequency=True): """ TODO: Docu """ StepAnalyzedCommon.__init__(self, fname, BoundingLogAnalyzer(doTimelines=True, doFiles=writeFiles, progress=progress, singleFile=singleFile, startTime=start, endTime=end), writePickled=writePickled, smallestFreq=smallestFreq, adaptFrequency=adaptFrequency) self.startTime = start self.endTime = end self.plots = {} self.createPlots(persist=persist, raiseit=raiseit, start=start, end=end, writeFiles=writeFiles, splitThres=splitThres, plotLinear=plotLinear, plotCont=plotCont, plotBound=plotBound, plotIterations=plotIterations, plotCourant=plotCourant, plotExecution=plotExecution, plotDeltaT=plotDeltaT, customRegexp=customRegexp, gnuplotTerminal=gnuplotTerminal, plottingImplementation=plottingImplementation) self.hardcopy = hardcopy self.hardcopyFormat = hardcopyFormat self.hardcopyPrefix = hardcopyPrefix self.hardcopyTerminalOptions = hardcopyTerminalOptions
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() print "Last Time = ", dire.getLast() # Get the pressure difference (Using an external utility) pUtil = UtilityRunner(argv=[pCmd, "-case", case], silent=True, logname="Pressure") pUtil.add("deltaP", "Pressure at .* Difference .*\] (.+)") pUtil.start() deltaP = pUtil.get("deltaP")[0]
y_O2 = (1 - f)*0.2315 y_N2 = 1-y_O2 -f for line in fileinput.input('0/O2',inplace=True): print(line.replace('uniform', 'uniform %s; //' % str(y_O2))), for line in fileinput.input('0/N2',inplace=True): print(line.replace('uniform', 'uniform %s; //' % str(y_N2))), for line in fileinput.input('0/T',inplace=True): print(line.replace('uniform', 'uniform %s; //' % str(T_start))), # replace the for line in fileinput.input('system/controlDict',inplace=True): print(line.replace('endTime', 'endTime %s; //' % str(t_end))), run=ConvergenceRunner(BoundingLogAnalyzer(),argv=[solver],silent=True) print('Starting: ',solver) run.start() print('Done!\n') # remove all the log files print('Cleaning up!') allFiles = os.listdir('.') rmFiles = [f for f in allFiles if f.startswith('PyFoam')] for file in rmFiles: try: os.remove(file) except: print('Could not remove: ', file)