def run(self): if not self.opts.keepPostprocessing: self.opts.additional.append("postProcessing") for cName in self.parser.getArgs(): if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.silent): self.addLocalConfig(cName) if self.opts.verbose: print_("Clearing", cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) sol.clear( after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, removeAnalyzed=self.parser.getOptions().removeAnalyzed, keepRegular=self.parser.getOptions().keepRegular, keepParallel=self.parser.getOptions().keepParallel, keepLast=self.parser.getOptions().latest, keepInterval=self.parser.getOptions().keepInterval, clearHistory=self.parser.getOptions().clearHistory, clearParameters=self.parser.getOptions().clearParameters, additional=self.parser.getOptions().additional, functionObjectData=self.parser.getOptions( ).functionObjectData) self.addToCaseLog(cName)
def recursiveCompress(self, dirName): if self.verbose > 1: print_("Recursively checking", dirName) if path.isdir(dirName): s = SolutionDirectory(dirName, archive=None, paraviewLink=False, parallel=True) if s.isValid(): try: self.compressCase(dirName) except OSError: e = sys.exc_info()[ 1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing", dirName, ":", e) return for f in listdir(dirName): name = path.join(dirName, f) try: if path.isdir(name): self.recursiveCompress(name) except OSError: e = sys.exc_info()[ 1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing", name, ":", 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 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 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 run(self): sol = SolutionDirectory(self.parser.getArgs()[0]) if not self.opts.init: vcs = sol.determineVCS() if vcs == None: self.error("not under version control") if not vcs in self.vcsChoices: self.error("Unsupported VCS", vcs) else: vcs = self.opts.vcs vcsInter = getVCS(vcs, path=sol.name, init=self.opts.init) vcsInter.addPath(path.join(sol.name, "constant"), rules=ruleList) vcsInter.addPath(path.join(sol.name, "system"), rules=ruleList) if sol.initialDir() != None: vcsInter.addPath(sol.initialDir(), rules=ruleList) else: self.warning("No initial-directory found") # special PyFoam-files for f in ["customRegexp", "LocalConfigPyFoam"]: p = path.join(sol.name, f) if path.exists(p): vcsInter.addPath(p, rules=ruleList) # Add the usual files from the tutorials for g in ["Allrun*", "Allclean*"]: for f in glob(path.join(sol.name, g)): vcsInter.addPath(f, rules=ruleList) for a in self.opts.additional: vcsInter.addPath(a, rules=ruleList) vcsInter.commit(self.opts.commitMessage)
def set_name(self, name): ''' handle the case renaming ''' new_path = os.path.join(os.path.dirname(self._path), name) os.rename(self._path, new_path) self._case = SolutionDirectory(new_path) self._path = new_path self.name = name
def run(self): if not self.opts.keepPostprocessing: self.opts.additional.append("postProcessing") for cName in self.parser.getArgs(): if self.checkCase(cName,fatal=self.opts.fatal,verbose=not self.opts.silent): self.addLocalConfig(cName) if self.opts.verbose: print_("Clearing",cName) sol=SolutionDirectory(cName,archive=None,paraviewLink=False) sol.clear(after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, removeAnalyzed=self.parser.getOptions().removeAnalyzed, keepRegular=self.parser.getOptions().keepRegular, keepParallel=self.parser.getOptions().keepParallel, keepLast=self.parser.getOptions().latest, keepInterval=self.parser.getOptions().keepInterval, clearHistory=self.parser.getOptions().clearHistory, clearParameters=self.parser.getOptions().clearParameters, additional=self.parser.getOptions().additional, functionObjectData=self.parser.getOptions().functionObjectData) self.addToCaseLog(cName)
def run(self): cName = self.parser.getArgs()[0] if self.opts.cloneCase: if self.opts.autoCasename: cName = path.join( cName, path.basename(self.opts.cloneCase) + buildFilenameExtension(self.opts.valuesDicts, self.opts.values)) if path.exists(cName): self.error( cName, "already existing (case should not exist when used with --clone-case)" ) if self.checkCase(self.opts.cloneCase, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(self.opts.cloneCase) orig = SolutionDirectory(self.opts.cloneCase, archive=None, paraviewLink=False) sol = orig.cloneCase(cName) else: if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) try: self.__lastMessage = None self.prepare(sol, cName=cName) except: if self.__lastMessage: self.__writeToStateFile(sol, self.__lastMessage + " failed") raise
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 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 reset(self): pid = self.worker_index #os.getpid() # logger_g.info(f'{pid}') self.casename = 'baseCase_'+str(pid) self.csvfile = 'progress_'+str(pid)+'.csv' orig = SolutionDirectory(origcase,archive=None,paraviewLink=False) case = orig.cloneCase(self.casename ) control_dict = ParsedParameterFile(path.join(self.casename,"system", "controlDict")) control_dict["endTime"] = self.end_time control_dict["writeInterval"] = self.write_interval control_dict.writeFile() # remove old log files with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm {self.casename}/log.*', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm -r {self.casename}/0.* {self.casename}/[1-9]*', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm -r {self.casename}/VTK', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories # subprocess.run( # f'rm -r postProcessing', # shell=True, # stderr=subprocess.STDOUT # ) self.count_parameters = 0 if self.states_type == 1: #self.actions[self.count_parameters] = self.a1[0] self.state = np.array([self.a1[0]]) elif self.states_type == 2: self.state = np.hstack((self.a1,self.reward)) return np.array(self.state)
def run(self): files=self.parser.getArgs()[0:] if len(files)==1 and path.isdir(files[0]): sol=SolutionDirectory( self.parser.getArgs()[0], archive=None, parallel=self.opts.parallelTimes, paraviewLink=False) self.processTimestepOptions(sol) if len(self.opts.time)<1: self.error("No time specified") globStr=self.parser.getArgs()[0] if self.opts.parallelTimes: globStr=path.join(globStr,"processor*") usedTime=sol.timeName(self.opts.time[0]) globStr=path.join(globStr, usedTime, "uniform","profiling*") files=glob(globStr) print_("Profiling info from time",usedTime) if len(files)<1: self.error("No profiling data found") elif len(files)>1: lst=[] for f in files: lst.append(self.readProfilingInfo(f)) dataAll,children0,root0=lst[0] for i in dataAll: d=dataAll[i] d["totalTimeMin"]=d["totalTime"] d["totalTimeMax"]=d["totalTime"] d["callsMin"]=d["calls"] d["callsMax"]=d["calls"] for data,children,root in lst[1:]: if root0!=root or children!=children0 or data.keys()!=dataAll.keys(): self.error("Inconsistent profiling data. Probably not from same run/timestep") for i in data: d=data[i] s=dataAll[i] s["totalTime"]+=d["totalTime"] s["totalTimeMin"]=min(s["totalTimeMin"],d["totalTime"]) s["totalTimeMax"]=max(s["totalTimeMax"],d["totalTime"]) s["calls"]+=d["calls"] s["callsMin"]=min(s["callsMin"],d["calls"]) s["callsMax"]=max(s["callsMax"],d["calls"]) s["childTime"]+=d["childTime"] for i in dataAll: d=dataAll[i] d["totalTime"]=d["totalTime"]/len(lst) d["childTime"]=d["childTime"]/len(lst) d["calls"]=d["calls"]/len(lst) self.printProfilingInfo(dataAll,children,root,True) else: data,children,root=self.readProfilingInfo(files[0]) self.printProfilingInfo(data,children,root)
def run(self): files = self.parser.getArgs()[0:] if len(files) == 1 and path.isdir(files[0]): sol = SolutionDirectory(self.parser.getArgs()[0], archive=None, parallel=self.opts.parallelTimes, paraviewLink=False) self.processTimestepOptions(sol) if len(self.opts.time) < 1: self.error("No time specified") globStr = self.parser.getArgs()[0] if self.opts.parallelTimes: globStr = path.join(globStr, "processor*") usedTime = sol.timeName(self.opts.time[0]) globStr = path.join(globStr, usedTime, "uniform", "profiling*") files = glob(globStr) print_("Profiling info from time", usedTime) if len(files) < 1: self.error("No profiling data found") elif len(files) > 1: lst = [] for f in files: lst.append(self.readProfilingInfo(f)) dataAll, children0, root0 = lst[0] for i in dataAll: d = dataAll[i] d["totalTimeMin"] = d["totalTime"] d["totalTimeMax"] = d["totalTime"] d["callsMin"] = d["calls"] d["callsMax"] = d["calls"] for data, children, root in lst[1:]: if root0 != root or children != children0 or data.keys( ) != dataAll.keys(): self.error( "Inconsistent profiling data. Probably not from same run/timestep" ) for i in data: d = data[i] s = dataAll[i] s["totalTime"] += d["totalTime"] s["totalTimeMin"] = min(s["totalTimeMin"], d["totalTime"]) s["totalTimeMax"] = max(s["totalTimeMax"], d["totalTime"]) s["calls"] += d["calls"] s["callsMin"] = min(s["callsMin"], d["calls"]) s["callsMax"] = max(s["callsMax"], d["calls"]) s["childTime"] += d["childTime"] for i in dataAll: d = dataAll[i] d["totalTime"] = d["totalTime"] / len(lst) d["childTime"] = d["childTime"] / len(lst) d["calls"] = d["calls"] / len(lst) self.printProfilingInfo(dataAll, children, root, True) else: data, children, root = self.readProfilingInfo(files[0]) self.printProfilingInfo(data, children, root)
def additionalReconstruct(self,parameters): sol=SolutionDirectory(self.casename()) if len(sol.processorDirs())>0: for t in listdir(path.join(self.casename(),sol.processorDirs()[0])): try: tm=float(t) self.foamRun("reconstructParMesh",foamArgs=["-time",t]) self.foamRun("reconstructPar",foamArgs=["-time",t]) except ValueError: print "Skipping",t
def test_with_broyden(self): """ broyden test """ if not foamVersionNumber() in [(2,3),(2,2)]: raise unittest.SkipTest("need ver.2.3 or 2.2 for this unittest.") cavityTut = os.path.join(foamTutorials(), "incompressible/icoFoam/cavity") if not os.path.exists(cavityTut): raise unittest.SkipTest("need $FOAM_TUTORIALS/incompressible/cavity \ for unittest.") try: shutil.copytree(cavityTut, os.path.join(self.tmpDir,"cavity")) cavityCase = SolutionDirectory(os.path.join(self.tmpDir,"cavity")) except: raise unittest.SkipTest("can not copy cavity case to temp_dir.") #create Allrun with open(os.path.join(cavityCase.name,"Allrun"),'w') as fp: fp.write('#!/bin/sh\nblockMesh>log.blockMesh\nicoFoam>log.icoFoam\n') os.chmod(os.path.join(cavityCase.name,"Allrun"),0777) #append controlDict fObj=""" functions { probes { type probes; functionObjectLibs ("libsampling.so"); enabled true; outputControl timeStep; outputInterval 1; fields ( p ); probeLocations ( ( 0.1 0.0925 0.005 ) ); } } """ with open(cavityCase.controlDict(),'a') as fp: fp.write(fObj) #test start sim = set_as_top(BroydenCavityInstance()) sim.cavity.case_dir = cavityCase.name sim.run() self.assertEqual(round(sim.cavity.nu,4),0.01)
def additionalReconstruct(self, parameters): sol = SolutionDirectory(self.casename()) if len(sol.processorDirs()) > 0: for t in listdir(path.join(self.casename(), sol.processorDirs()[0])): try: tm = float(t) self.foamRun("reconstructParMesh", foamArgs=["-time", t]) self.foamRun("reconstructPar", foamArgs=["-time", t]) except ValueError: print "Skipping", t
def __init__(self, input): """:param input: either a SolutionDirectory-instance or a string with a pathname""" if isinstance(input, SolutionDirectory): self.__sol = input elif isinstance(input, string_types): self.__sol = SolutionDirectory(input, paraviewLink=False, archive=None) else: error(type(input), "not supported")
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 run(self): if not self.opts.keepPostprocessing: self.opts.additional.append("postProcessing") notCleared=[] if self.opts.dryRun: self.opts.verbose=True self.opts.verboseClear=True for cName in self.parser.getArgs(): if self.checkCase(cName,fatal=self.opts.fatal,verbose=not self.opts.silent): if self.opts.allcleanScript: scr=path.join(cName,"Allclean") if(path.exists(scr)): if self.opts.verbose or self.opts.verboseClear: print("Executing",scr) execute(scr,workdir=cName) try: self.addLocalConfig(cName) if self.opts.verbose: print_("Clearing",cName) sol=SolutionDirectory(cName, archive=None, parallel=True, paraviewLink=False) sol.clear(after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, verbose=self.parser.getOptions().verboseClear, removeAnalyzed=self.parser.getOptions().removeAnalyzed, keepRegular=self.parser.getOptions().keepRegular, keepParallel=self.parser.getOptions().keepParallel, keepLast=self.parser.getOptions().latest, keepInterval=self.parser.getOptions().keepInterval, keepTimes=self.opts.keepTimes, clearHistory=self.parser.getOptions().clearHistory, clearParameters=self.parser.getOptions().clearParameters, additional=self.parser.getOptions().additional, dryRun=self.opts.dryRun, functionObjectData=self.parser.getOptions().functionObjectData) self.addToCaseLog(cName) except OSError: e = sys.exc_info()[1] # compatible with 2.x and 3.x self.warning("Can not clear",cName,"because of OSError",e) notCleared.append(cName) if len(notCleared)>0: self.warning("These case not cleared because of OS-problems:", ", ".join(notCleared))
def run(self): if self.opts.file: sys.stdout = open(self.opts.file, "w") if self.opts.allRegions: sol = SolutionDirectory( self.parser.getArgs()[0], archive=None, parallel=self.opts.parallel, paraviewLink=False ) for r in sol.getRegions(): self.doRegion(r) else: self.doRegion(self.opts.region)
def __init__(self, folder): self._folder = folder self._case = SolutionDirectory(folder) self._path = self._case.name self.name = os.path.basename(self._path) self.__dict__.update({ 'set_snappyHexMesh': partial(self.set_dictSettings, 'snappyHexMeshDict'), 'set_fvSchemes': partial(self.set_dictSettings, 'fvSchemes'), 'set_fvSolution': partial(self.set_dictSettings, 'fvSolution'), })
def run(self): sName = self.parser.getArgs()[0] if sName[-1] == path.sep: sName = sName[:-1] if self.parser.getOptions().tarname != None: dName = self.parser.getOptions().tarname else: if sName == path.curdir: dName = path.basename(path.abspath(sName)) else: dName = sName dName += ".tgz" if self.parser.getOptions().pyfoam: self.parser.getOptions().additional.append("PyFoam*") sol = SolutionDirectory(sName, archive=None, addLocalConfig=True, paraviewLink=False) if not sol.isValid(): self.error(sName, "does not look like real OpenFOAM-case because", sol.missingFiles(), "are missing or of the wrong type") if self.parser.getOptions().chemkin: sol.addToClone("chemkin") if self.opts.noPloyMesh: self.parser.getOptions().exclude.append("polyMesh") sol.packCase(dName, last=self.parser.getOptions().last, additional=self.parser.getOptions().additional, exclude=self.parser.getOptions().exclude, base=self.parser.getOptions().basename)
def timeChanged(self): self.nSteps += 1 self.currTime = self.analyzer.time self.progressString = self.analyzer.progressOut.lastProgress() if self.analyzer.hasAnalyzer("Execution"): self.clockTime = self.analyzer.getAnalyzer( "Execution").clockTotal() if self.startTime is None: if self.runner: self.startTime = self.runner.createTime else: self.startTime = self.analyzer.getAnalyzer("Time").createTime() if self.endTime is None: sol = None if self.runner: sol = self.runner.getSolutionDirectory() else: if self.analyzer.hasAnalyzer("ExecName"): caseName = self.analyzer.getAnalyzer("ExecName").caseName if caseName and path.isdir(caseName): from PyFoam.RunDictionary.SolutionDirectory import SolutionDirectory sol = SolutionDirectory(caseName, paraviewLink=False) if sol: from PyFoam.RunDictionary.ParameterFile import ParameterFile control = ParameterFile(sol.controlDict()) try: self.endTime = float(control.readParameter("endTime")) except ValueError: self.endTime = -1 if self.caseName is None or self.execName is None: if self.analyzer.hasAnalyzer("ExecName"): self.caseName = self.analyzer.getAnalyzer("ExecName").caseName self.execName = self.analyzer.getAnalyzer("ExecName").execName self.headerChanged = True from PyFoam.LogAnalysis.LogLineAnalyzer import LogLineAnalyzer for e in LogLineAnalyzer.allRegexp: addExpr(e) if self.firstTime: self.update(resize=True) self.firstTime = False else: self._checkHeaders(force=True)
def create_case(self, wind_dict, params): """ 0. cloning case 1. creating snappyHexMeshDict and blockMeshdict according to flow direction and other parameters 2. creating the blockMesh 3. change the boundary conditions 4. decomposing the domain 5. creating the snappyHexMesh - running in parallel (sfoam.py or not - depending on user input) 6. decomposing the created mesh """ #-------------------------------------------------------------------------------------- # cloning case #-------------------------------------------------------------------------------------- target = params['case_dir'] target = os.path.realpath(target) if not os.path.exists(target): makedirs(target) template = read_dict_string(wind_dict, 'template') self._r.debug("template = %r, target = %r" % (template, target)) orig = SolutionDirectory(template, archive=None, paraviewLink=False) work = orig.cloneCase(target) #-- # creating dictionaries #-- if wind_dict['procnr'] > multiprocessing.cpu_count(): self._r.warn( 'wind_dict contains a higher processor number then the machine has' ) wind_dict['procnr'] = min(wind_dict['procnr'], multiprocessing.cpu_count()) phi = params['wind_dir'] * pi / 180 params['phi'] = phi # - pi/180 * 90 self._r.status('creating block mesh dictionary') self.create_block_mesh_dict(work, wind_dict, params) self._r.status('creating snappy hex mesh dictionary') self.create_SHM_dict(work, wind_dict, params) self._r.status('creating boundary conditions dictionary') self.create_boundary_conditions_dict(work, wind_dict, params) self._r.status('running block mesh') self.run_block_mesh(work) self._r.status('running decompose') self.run_decompose(work, wind_dict) self._r.status('running snappy hex mesh') self.run_SHM(work, wind_dict) self._r.status('running second decompose') self.run_decompose(work, wind_dict) return work
def solution(self): """Access to a SolutionDirectory-object that represents the current solution""" if not hasattr(self,"_solution"): self._solution=SolutionDirectory(self.caseDir, archive=None) return self._solution
def timeChanged(self): self.nSteps+=1 self.currTime=self.analyzer.time self.progressString=self.analyzer.progressOut.lastProgress() if self.analyzer.hasAnalyzer("Execution"): self.clockTime=self.analyzer.getAnalyzer("Execution").clockTotal() if self.startTime is None: if self.runner: self.startTime=self.runner.createTime else: self.startTime=self.analyzer.getAnalyzer("Time").createTime() if self.endTime is None: sol=None if self.runner: sol=self.runner.getSolutionDirectory() else: if self.analyzer.hasAnalyzer("ExecName"): caseName=self.analyzer.getAnalyzer("ExecName").caseName if caseName and path.isdir(caseName): from PyFoam.RunDictionary.SolutionDirectory import SolutionDirectory sol=SolutionDirectory(caseName,paraviewLink=False) if sol: from PyFoam.RunDictionary.ParameterFile import ParameterFile control=ParameterFile(sol.controlDict()) try: self.endTime=float(control.readParameter("endTime")) except ValueError: self.endTime=-1 if self.caseName is None or self.execName is None: if self.analyzer.hasAnalyzer("ExecName"): self.caseName=self.analyzer.getAnalyzer("ExecName").caseName self.execName=self.analyzer.getAnalyzer("ExecName").execName self.headerChanged=True from PyFoam.LogAnalysis.LogLineAnalyzer import LogLineAnalyzer for e in LogLineAnalyzer.allRegexp: addExpr(e) if self.firstTime: self.update(resize=True) self.firstTime=False else: self._checkHeaders(force=True)
def create_case(self, wind_dict, params): """ 0. cloning case 1. creating snappyHexMeshDict and blockMeshdict according to flow direction and other parameters 2. creating the blockMesh 3. change the boundary conditions 4. decomposing the domain 5. creating the snappyHexMesh - running in parallel (sfoam.py or not - depending on user input) 6. decomposing the created mesh """ #-------------------------------------------------------------------------------------- # cloning case #-------------------------------------------------------------------------------------- target = params['case_dir'] target = os.path.realpath(target) if not os.path.exists(target): makedirs(target) template = read_dict_string(wind_dict, 'template') self._r.debug("template = %r, target = %r" % (template, target)) orig = SolutionDirectory(template, archive=None, paraviewLink=False) work = orig.cloneCase(target) #-- # creating dictionaries #-- if wind_dict['procnr'] > multiprocessing.cpu_count(): self._r.warn('wind_dict contains a higher processor number then the machine has') wind_dict['procnr'] = min(wind_dict['procnr'], multiprocessing.cpu_count()) phi = params['wind_dir'] * pi / 180 params['phi'] = phi # - pi/180 * 90 self._r.status('creating block mesh dictionary') self.create_block_mesh_dict(work, wind_dict, params) self._r.status('creating snappy hex mesh dictionary') self.create_SHM_dict(work, wind_dict, params) self._r.status('creating boundary conditions dictionary') self.create_boundary_conditions_dict(work, wind_dict, params) self._r.status('running block mesh') self.run_block_mesh(work) self._r.status('running decompose') self.run_decompose(work, wind_dict) self._r.status('running snappy hex mesh') self.run_SHM(work, wind_dict) self._r.status('running second decompose') self.run_decompose(work, wind_dict) return work
def run(self): cName = self.parser.getArgs()[0] if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) self.prepare(sol, cName=cName)
def testSolutionDirectoryBasicContainerStuff(self): test=SolutionDirectory(self.theFile) self.assertEqual(len(test),1) self.assert_("0" in test) self.assert_("1e-7" in test) self.assert_("1e-4" not in test) self.assert_(0. in test) td=test["0"] self.assertEqual(type(td),TimeDirectory) self.assertRaises(KeyError,test.__getitem__,"42") td=test[-1] self.assertEqual(type(td),TimeDirectory) lst=[] for t in test: lst.append(t.baseName()) self.assertEqual(len(test),len(lst)) self.assertEqual(lst,test.getTimes())
def testRoundtripBlockMesh(self): blk = ParsedBlockMeshDict(SolutionDirectory(self.dest).blockMesh()) txt = str(blk) try: i = int(txt.split("blocks")[1].split("(")[0]) self.assertTrue(False) except ValueError: pass
def cloneCase(self, name, svnRemove=True, followSymlinks=False): out = SolutionDirectory.cloneCase(self, name, svnRemove=svnRemove, followSymlinks=followSymlinks) out.inletPatch = self.inletPatch out.updateInletVelocity() return out
def run(self): sName=self.parser.getArgs()[0] if sName[-1]==path.sep: sName=sName[:-1] if self.parser.getOptions().tarname!=None: dName=self.parser.getOptions().tarname else: dName=sName+".tgz" if self.parser.getOptions().pyfoam: self.parser.getOptions().additional.append("PyFoam*") sol=SolutionDirectory(sName,archive=None,paraviewLink=False) if not sol.isValid(): self.error(sName,"does not look like real OpenFOAM-case because",sol.missingFiles(),"are missing or of the wrong type") if self.parser.getOptions().chemkin: sol.addToClone("chemkin") if self.opts.noPloyMesh: self.parser.getOptions().exclude.append("polyMesh") sol.packCase(dName, last=self.parser.getOptions().last, additional=self.parser.getOptions().additional, exclude=self.parser.getOptions().exclude, base=self.parser.getOptions().basename)
def run(self): cName = self.parser.getArgs()[0] sol = SolutionDirectory(cName, archive=None) self.addLocalConfig(cName) initial = sol[0] if "U" not in initial or "p" not in initial: error("Either 'p' or 'U' missing from the initial directory", initial.baseName()) if self.opts.writep: initial["p.prepotential"] = initial["p"] initial["U.prepotential"] = initial["U"] lam = self.getParallel(sol) if self.opts.writep: writep = ["-writep"] else: writep = [] argv = ["potentialFoam"] if oldApp(): argv += [".", cName] else: argv += ["-case", cName] self.setLogname(default="Potential", useApplication=False) self.checkAndCommit(sol) run = BasicRunner(argv=argv + writep, server=self.opts.server, logname=self.opts.logname, compressLog=self.opts.compress, silent=self.opts.progress or self.opts.silent, lam=lam, logTail=self.opts.logTail, echoCommandLine=self.opts.echoCommandPrefix, noLog=self.opts.noLog) print_("Setting system-directory for potentialFoam") trig = PotentialTrigger(sol, self.opts.noCorr, self.opts.tolerance, self.opts.relTol, pRefCell=self.opts.pRefCell, pRefValue=self.opts.pRefValue, removeLibs=self.opts.removeLibs, removeFunctions=self.opts.removeFunctions) run.addEndTrigger(trig.resetIt) self.addToCaseLog(cName, "Starting") run.start() self.setData(run.data) self.addToCaseLog(cName, "Ending")
def caseDirectory(): """The directory in which the case is stored""" try: # old school paraview fName = path.dirname(paraFoamReader().FileName.GetData()) except AttributeError: fName = path.dirname(paraFoamReader().FileName) return SolutionDirectory(fName, archive=None, paraviewLink=False)
def run(self): if len(self.parser.getArgs()) != 2: error("Need two arguments.", len(self.parser.getArgs()), "found") sName = self.parser.getArgs()[0] dName = self.parser.getArgs()[1] if self.opts.include == None: include = ["*"] else: include = self.opts.include if self.opts.exclude == None: exclude = [] else: exclude = self.opts.exclude source = SolutionDirectory(sName, archive=None, paraviewLink=False) dest = SolutionDirectory(dName, archive=None, paraviewLink=False) sDir = source[-1] dDir = dest[0] if self.opts.verbose: print_(" Copying from source-time", sDir.baseName(), "to destination-time", dDir.baseName()) copied = dDir.copy(sDir, include=include, exclude=exclude, overwrite=self.opts.overwrite, mustExist=self.opts.mustExist, purge=self.opts.purge) if self.opts.verbose: if len(copied) > 0: print_(" Copied the fields", end=" ") for v in copied: print_(v, end=" ") print_() else: print_(" Nothing copied") self.addToCaseLog(dest.name, "From", sDir.name, "to", dDir.name)
def compressCase(self, dirName, warn=False): if not path.exists(dirName): self.error("Directory", dirName, "does not exist") s = SolutionDirectory(dirName, archive=None, paraviewLink=False, parallel=True, tolerant=True) if not s.isValid(): if warn: print_("Directory", dirName, "is not an OpenFOAM-case") return self.nrDir += 1 oldNr = self.nrFiles oldUnc = self.prevSize oldCon = self.nowSize if self.verbose > 0: print_("Processing case", dirName) # compress meshes for d in glob(path.join(dirName, "*", "polyMesh")) + glob( path.join(dirName, "*", "*", "polyMesh")): if path.isdir(d): self.compressDirectory(d) # compress times for t in s: self.compressDirectory(t.name) # compress logfiles if requested if self.opts.logfile: for f in glob(path.join(dirName, "*.logfile")): self.compressFile(path.join(dirName, f)) # processor direcories for p in s.procDirs: self.compressDirectory(path.join(dirName, p)) if self.nrFiles > oldNr and self.verbose > 0: print_( " -> ", self.nrFiles - oldNr, "files compressed.", humanReadableSize((self.prevSize - oldUnc) - (self.nowSize - oldCon)), "gained")
def create(self, caseName, input_parameters): direTemplate = SolutionDirectory(self.template) for f in self.clone_files: direTemplate.addToClone(f) dire = direTemplate.cloneCase(caseName) parameters = ParsedParameterFile(os.path.join(dire.name, "parameters")) for key, value in input_parameters.items(): parameters[key] = value parameters.writeFile() if self.np > 1: decomposeParDict = ParsedParameterFile( os.path.join(dire.systemDir(), "decomposeParDict")) decomposeParDict["numberOfSubdomains"] = self.np decomposeParDict.writeFile() self.dire = dire
def testBoundaryRead(self): blk = ParsedBlockMeshDict(SolutionDirectory(self.dest).blockMesh()) self.assertEqual(blk.convertToMeters(), 1.) self.assertEqual(len(blk.vertices()), 22) self.assertEqual(len(blk.blocks()), 5) self.assertEqual(len(blk.patches()), 6) self.assertEqual(len(blk.arcs()), 8) self.assertEqual(blk.typicalLength(), 1.25) self.assertEqual(str(blk.getBounds()), "([0.0, 0.0, 0.0], [2.0, 2.0, 0.5])")
def testTimeReplacingZippedFile(self): test = SolutionDirectory(self.theFile)["0"] self.assertEqual(len(test), 4) if foamFork() in ["openfoam", "openfoamplus" ] and foamVersionNumber() >= (4, ): extension = ".orig" else: extension = ".org" test[gammaName()] = test[gammaName() + extension] self.assertEqual(len(test), 4)
def testTimeCopy(self): test=SolutionDirectory(self.theFile) self.assertEqual(len(test),1) test["42"]=test[0] self.assertEqual(len(test),2) self.assertEqual(len(test["42"]),len(test[0])) del test["42"] self.assertEqual(len(test),1) del test[-1] self.assertEqual(len(test),0)
def run(self): for cName in self.parser.getArgs(): if self.checkCase(cName,fatal=self.opts.fatal,verbose=not self.opts.silent): self.addLocalConfig(cName) if self.opts.verbose: print "Clearing",cName sol=SolutionDirectory(cName,archive=None,paraviewLink=False) sol.clear(after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, keepRegular=self.parser.getOptions().keepRegular, keepLast=self.parser.getOptions().latest, clearHistory=self.parser.getOptions().clearHistory, functionObjectData=self.parser.getOptions().functionObjectData) self.addToCaseLog(cName)
def __init__(self, case, time="constant", processor=None, region=None): """@param case: Path to the case-directory @param time: Time for which the mesh should be looked at @param processor: Name of the processor directory for decomposed cases""" self.sol=SolutionDirectory(case,paraviewLink=False,archive=None,region=region) self.time=time self.processor=processor
def __init__(self,input): """@param input: either a SolutionDirectory-instance or a string with a pathname""" if isinstance(input,SolutionDirectory): self.__sol=input elif isinstance(input,string_types): self.__sol=SolutionDirectory(input, paraviewLink=False, archive=None) else: error(type(input),"not supported")
def compressCase(self,dirName,warn=False): if not path.exists(dirName): self.error("Directory",dirName,"does not exist") s=SolutionDirectory(dirName, archive=None, paraviewLink=False, parallel=True, tolerant=True) if not s.isValid(): if warn: print_("Directory",dirName,"is not an OpenFOAM-case") return self.nrDir+=1 oldNr=self.nrFiles oldUnc=self.prevSize oldCon=self.nowSize if self.verbose>0: print_("Processing case",dirName) # compress meshes for d in glob(path.join(dirName,"*","polyMesh"))+glob(path.join(dirName,"*","*","polyMesh")): if path.isdir(d): self.compressDirectory(d) # compress times for t in s: self.compressDirectory(t.name) # compress logfiles if requested if self.opts.logfile: for f in glob(path.join(dirName,"*.logfile")): self.compressFile(path.join(dirName,f)) # processor direcories for p in s.procDirs: self.compressDirectory(path.join(dirName,p)) if self.nrFiles>oldNr and self.verbose>0: print_(" -> ",self.nrFiles-oldNr,"files compressed.", humanReadableSize((self.prevSize-oldUnc)-(self.nowSize-oldCon)),"gained")
def recursiveCompress(self,dirName): if self.verbose>1: print_("Recursively checking",dirName) if path.isdir(dirName): s=SolutionDirectory(dirName,archive=None,paraviewLink=False,parallel=True) if s.isValid(): try: self.compressCase(dirName) except OSError: e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing",dirName,":",e) return for f in listdir(dirName): name=path.join(dirName,f) try: if path.isdir(name): self.recursiveCompress(name) except OSError: e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing",name,":",e)
def _input_trait_modified(self, obj, name, old, new): """hook th changing a trait.""" super(FoamBaseComponent, self)._input_trait_modified(obj, name, old, new) if name == 'case_dir': caseDir = self.getPath(new,False) if not caseDir == None: #type(caseDir) is str or unicode self.foam_case = SolutionDirectory(str(caseDir)) else: self.raise_exception("case_dir '%s' was" " not found." % new, RuntimeError)
def run(self): oldStdout=None try: if self.opts.file: oldStdout=sys.stdout if isinstance(self.opts.file,string_types): sys.stdout=open(self.opts.file,"w") else: sys.stdout=self.opts.file if self.opts.allRegions: sol=SolutionDirectory(self.parser.getArgs()[0], archive=None, parallel=self.opts.parallel, paraviewLink=False) for r in sol.getRegions(): self.doRegion(r) else: self.doRegion(self.opts.region) finally: if oldStdout: sys.stdout=oldStdout
def run(self): sol=SolutionDirectory(self.parser.getArgs()[0]) if not self.opts.init: vcs=sol.determineVCS() if vcs==None: self.error("not under version control") if not vcs in self.vcsChoices: self.error("Unsupported VCS",vcs) else: vcs=self.opts.vcs vcsInter=getVCS(vcs, path=sol.name, init=self.opts.init) vcsInter.addPath(path.join(sol.name,"constant"),rules=ruleList) vcsInter.addPath(path.join(sol.name,"system"),rules=ruleList) if sol.initialDir()!=None: vcsInter.addPath(sol.initialDir(),rules=ruleList) else: self.warning("No initial-directory found") # special PyFoam-files for f in ["customRegexp","LocalConfigPyFoam"]: p=path.join(sol.name,f) if path.exists(p): vcsInter.addPath(p,rules=ruleList) # Add the usual files from the tutorials for g in ["Allrun*","Allclean*"]: for f in glob(path.join(sol.name,g)): vcsInter.addPath(f,rules=ruleList) for a in self.opts.additional: vcsInter.addPath(a,rules=ruleList) vcsInter.commit(self.opts.commitMessage)
def run(self): cName=self.parser.getArgs()[0] if self.opts.cloneCase: if self.opts.autoCasename: cName=path.join(cName, path.basename(self.opts.cloneCase)+ buildFilenameExtension(self.opts.valuesDicts, self.opts.values)) if path.exists(cName): self.error(cName,"already existing (case should not exist when used with --clone-case)") if self.checkCase(self.opts.cloneCase, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(self.opts.cloneCase) orig=SolutionDirectory(self.opts.cloneCase, archive=None,paraviewLink=False) sol=orig.cloneCase(cName) else: if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(cName) sol=SolutionDirectory(cName,archive=None,paraviewLink=False) self.prepare(sol,cName=cName)
def __init__(self): """Component.__init__() and check the path to icoFoam.""" super(FoamBaseComponent, self).__init__() self.foam_case = None #Check OpenFOAM commands in $PATH. if not self._which("icoFoam"): self.raise_exception("OpenFOAM command is not found. Check $PATH.", RuntimeError) if not self.case_dir == '': caseDir = self.getPath(self.case_dir, False) if not caseDir == None: #type(caseDir) is str or unicode self.foam_case = SolutionDirectory(str(caseDir))
class MeshInformation: """Reads Information about the mesh on demand""" def __init__(self, case, time="constant", processor=None, region=None): """@param case: Path to the case-directory @param time: Time for which the mesh should be looked at @param processor: Name of the processor directory for decomposed cases""" self.sol=SolutionDirectory(case,paraviewLink=False,archive=None,region=region) self.time=time self.processor=processor def nrOfFaces(self): try: return self.faces except AttributeError: try: faces=ListFile(self.sol.polyMeshDir(time=self.time,processor=self.processor),"faces") self.faces=faces.getSize() except IOError: faces=ListFile(self.sol.polyMeshDir(processor=self.processor),"faces") self.faces=faces.getSize() return self.faces def nrOfPoints(self): try: return self.points except AttributeError: try: points=ListFile(self.sol.polyMeshDir(time=self.time,processor=self.processor),"points") self.points=points.getSize() except IOError: points=ListFile(self.sol.polyMeshDir(processor=self.processor),"points") self.points=points.getSize() return self.points def nrOfCells(self): try: return self.cells except: try: try: owner=ParsedFileHeader(path.join(self.sol.polyMeshDir(time=self.time,processor=self.processor),"owner")) except IOError: owner=ParsedFileHeader(path.join(self.sol.polyMeshDir(processor=self.processor),"owner")) mat=re.compile('.+nCells: *([0-9]+) .+').match(owner["note"]) self.cells=int(mat.group(1)) return self.cells except: raise PyFoamException("Not Implemented")
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.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) 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={} 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 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() d[name]=v variation.append(d) return variation else: return [{name:v} for v in vals] variations=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.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.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, 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_, 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 run(self): decomposeParWithRegion=(foamVersion()>=(1,6)) 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 decomposeParWithRegion and self.opts.keeppseudo: warning("Option --keep-pseudocases doesn't make sense since OpenFOAM 1.6 because decomposePar supports regions") nr=int(self.parser.getArgs()[1]) if nr<2: error("Number of processors",nr,"too small (at least 2)") case=path.abspath(self.parser.getArgs()[0]) method=self.opts.method result={} result["numberOfSubdomains"]=nr result["method"]=method coeff={} result[method+"Coeffs"]=coeff if self.opts.globalFaceZones!=None: try: fZones=eval(self.opts.globalFaceZones) except SyntaxError: fZones=FoamStringParser( self.opts.globalFaceZones, listDict=True ).data result["globalFaceZones"]=fZones if method in ["metis","scotch","parMetis"]: if self.opts.processorWeights!=None: weigh=eval(self.opts.processorWeights) if nr!=len(weigh): error("Number of processors",nr,"and length of",weigh,"differ") coeff["processorWeights"]=weigh elif method=="manual": if self.opts.dataFile==None: error("Missing required option dataFile") else: coeff["dataFile"]="\""+self.opts.dataFile+"\"" elif method=="simple" or method=="hierarchical": if self.opts.n==None or self.opts.delta==None: error("Missing required option n or delta") n=eval(self.opts.n) if len(n)!=3: error("Needs to be three elements, not",n) if nr!=n[0]*n[1]*n[2]: error("Subdomains",n,"inconsistent with processor number",nr) coeff["n"]="(%d %d %d)" % (n[0],n[1],n[2]) coeff["delta"]=float(self.opts.delta) if method=="hierarchical": if self.opts.order==None: error("Missing reuired option order") if len(self.opts.order)!=3: error("Order needs to be three characters") coeff["order"]=self.opts.order else: error("Method",method,"not yet implementes") gen=FoamFileGenerator(result) if self.opts.test: print_(str(gen)) return -1 else: f=open(path.join(case,"system","decomposeParDict"),"w") writeDictionaryHeader(f) f.write(str(gen)) f.close() if self.opts.clear: print_("Clearing processors") for p in glob(path.join(case,"processor*")): print_("Removing",p) rmtree(p,ignore_errors=True) self.checkAndCommit(SolutionDirectory(case,archive=None)) if self.opts.doDecompose: if self.opts.region: regionNames=self.opts.region[:] while True: try: i=regionNames.index("region0") regionNames[i]=None except ValueError: break else: regionNames=[None] regions=None sol=SolutionDirectory(case) if not decomposeParWithRegion: if self.opts.regions or self.opts.region!=None: print_("Building Pseudocases") regions=RegionCases(sol,clean=True,processorDirs=False) if self.opts.regions: regionNames=sol.getRegions(defaultRegion=True) for theRegion in regionNames: theCase=path.normpath(case) if theRegion!=None and not decomposeParWithRegion: theCase+="."+theRegion if oldApp(): argv=[self.opts.decomposer,".",theCase] else: argv=[self.opts.decomposer,"-case",theCase] if foamVersion()>=(2,0) and not self.opts.doFunctionObjects: argv+=["-noFunctionObjects"] if theRegion!=None and decomposeParWithRegion: argv+=["-region",theRegion] f=open(path.join(case,"system",theRegion,"decomposeParDict"),"w") writeDictionaryHeader(f) f.write(str(gen)) f.close() self.setLogname(default="Decomposer",useApplication=False) run=UtilityRunner(argv=argv, silent=self.opts.progress or self.opts.silent, logname=self.opts.logname, compressLog=self.opts.compress, server=self.opts.server, noLog=self.opts.noLog, logTail=self.opts.logTail, echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.start() if theRegion!=None and not decomposeParWithRegion: print_("Syncing into master case") regions.resync(theRegion) if regions!=None and not decomposeParWithRegion: 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) if self.opts.doConstantLinks: print_("Adding symlinks in the constant directories") constPath=path.join(case,"constant") for f in listdir(constPath): srcExpr=path.join(path.pardir,path.pardir,"constant",f) for p in range(nr): dest=path.join(case,"processor%d"%p,"constant",f) if not path.exists(dest): symlink(srcExpr,dest) self.addToCaseLog(case)
def lookForCases(d): for n in tqdm(listdir(d), unit="entries", leave=False, desc=path.basename(path.abspath(d)), disable=not self.opts.progressBar): if not self.fnmatch(n): continue cName=path.join(d,n) if path.isdir(cName): try: sol=SolutionDirectory(cName,archive=None,paraviewLink=False) if sol.isValid(): if self.opts.progress: print_("Processing",cName) data={} data["mtime"]=stat(cName)[ST_MTIME] times=sol.getTimes() try: data["first"]=times[0] except IndexError: data["first"]="None" try: data["last"]=times[-1] except IndexError: data["last"]="None" data["nrSteps"]=len(times) data["procs"]=sol.nrProcs() data["pFirst"]=-1 data["pLast"]=-1 data["nrParallel"]=-1 if self.opts.parallel: pTimes=sol.getParallelTimes() data["nrParallel"]=len(pTimes) if len(pTimes)>0: data["pFirst"]=pTimes[0] data["pLast"]=pTimes[-1] data["name"]=cName data["diskusage"]=-1 if self.opts.diskusage: data["diskusage"]=diskUsage(cName) totalDiskusage+=data["diskusage"] if self.opts.parallel: for f in listdir(cName): if re.compile("processor[0-9]+").match(f): data["mtime"]=max(stat(path.join(cName,f))[ST_MTIME],data["mtime"]) if self.opts.state or self.opts.estimateEndTime: try: data["startedAt"]=time.mktime(time.strptime(self.readState(sol,"StartedAt"))) except ValueError: data["startedAt"]="nix" if self.opts.state: try: data["nowTime"]=float(self.readState(sol,"CurrentTime")) except ValueError: data["nowTime"]=None try: data["lastOutput"]=time.mktime(time.strptime(self.readState(sol,"LastOutputSeen"))) except ValueError: data["lastOutput"]="nix" data["state"]=self.readState(sol,"TheState") if data["state"]=="Running": try: gone=time.time()-data["lastOutput"] if gone>self.opts.deadThreshold: data["state"]="Dead "+humanReadableDuration(gone) except KeyError: pass except TypeError: pass if self.opts.startEndTime or self.opts.estimateEndTime: try: ctrlDict=ParsedParameterFile(sol.controlDict(),doMacroExpansion=True) except PyFoamParserError: # Didn't work with Macro expansion. Let's try without try: ctrlDict=ParsedParameterFile(sol.controlDict()) except PyFoamParserError: ctrlDict=None if ctrlDict: data["startTime"]=ctrlDict["startTime"] data["endTime"]=ctrlDict["endTime"] else: data["startTime"]=None data["endTime"]=None if self.opts.estimateEndTime: data["endTimeEstimate"]=None if self.readState(sol,"TheState")=="Running": gone=time.time()-data["startedAt"] try: current=float(self.readState(sol,"CurrentTime")) frac=(current-data["startTime"])/(data["endTime"]-data["startTime"]) except ValueError: frac=0 if frac>0: data["endTimeEstimate"]=data["startedAt"]+gone/frac if self.opts.hgInfo: if path.isdir(path.join(cName,".hg")): from stat import ST_ATIME prevStat=stat(cName) try: data["hgInfo"]=sub.Popen(["hg", "id", "-R",cName, "-b","-n","-i"], stdout=sub.PIPE).communicate()[0].strip() except OSError: data["hgInfo"]="<hg not working>" postStat=stat(cName) if prevStat[ST_MTIME]!=postStat[ST_MTIME]: # hg seems to modify the modification time of the directory. So reset it os.utime(cName,(postStat[ST_ATIME],prevStat[ST_MTIME])) else: data["hgInfo"]="<no .hg directory>" if len(customData)>0 or self.opts.hostname: fn=None pickleFile=None if useSolverInData: data["solver"]="none found" # try to find the oldest pickled file dirAndTime=[] for f in ["pickledData","pickledUnfinishedData","pickledStartData"]: for g in glob(path.join(cName,"*.analyzed")): pName=path.join(g,f) base=path.basename(g) if base.find("PyFoamRunner.")==0: solverName=base[len("PyFoamRunner."):-len(".analyzed")] else: solverName=None if path.exists(pName): dirAndTime.append((path.getmtime(pName),solverName,pName)) dirAndTime.sort(key=lambda x:x[0]) if len(dirAndTime)>0: data["solver"]=dirAndTime[-1][1] pickleFile=dirAndTime[-1][2] solverName=data["solver"] else: solverName=self.opts.solverNameForCustom if pickleFile: fn=pickleFile else: for f in ["pickledData","pickledUnfinishedData","pickledStartData"]: fp=path.join(cName,"PyFoamRunner."+solverName+".analyzed",f) if path.exists(fp): fn=fp break pickleOK=False if fn: try: raw=pickle.Unpickler(open(fn,"rb")).load() pickleOK=True for n,spec in customData: dt=raw for k in spec: try: dt=dt[k] except KeyError: dt="No key '"+k+"'" break if isinstance(dt,string_types): break data[n]=dt if self.opts.hostname: try: data["hostname"]=raw["hostname"].split(".")[0] except KeyError: data["hostname"]="<unspecified>" except ValueError: pass if not pickleOK: for n,spec in customData: data[n]="<no file>" if self.opts.hostname: data["hostname"]="<no file>" cData.append(data) elif self.opts.recursive: # print("Recurse",cName) lookForCases(cName) except OSError: print_(cName,"is unreadable")
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", if speedup==None: print "not ... because it failed" else: print "completely" rmtree(caseDir,ignore_errors=True) print print if lam!=None: lam.stop() print "Total Speedup: ",currentEstimate," ( ",totalSpeedup," / ",totalWeight, " ) Range: [",minSpeedup,",",maxSpeedup,"]" print runsOK,"of",len(benchCases),"ran OK" resultFile.write("Total Speedup: %g\n" % (currentEstimate)) if minSpeedup and maxSpeedup: resultFile.write("Range: [ %g , %g ]\n" % (minSpeedup,maxSpeedup)) resultFile.close()
class FoamBaseComponent(Component): """This class is base Component to execute OpenFOAM pre,main and post commands""" case_dir = Str("", iotype="in", desc='OpenFOAM Case Dir. Absolute path or relative path in $FOAM_RUN.') force_fd = Bool(True, iotype='in', framework_var=True, deriv_ignore=True, desc="If True, always finite difference this component.") def __init__(self): """Component.__init__() and check the path to icoFoam.""" super(FoamBaseComponent, self).__init__() self.foam_case = None #Check OpenFOAM commands in $PATH. if not self._which("icoFoam"): self.raise_exception("OpenFOAM command is not found. Check $PATH.", RuntimeError) if not self.case_dir == '': caseDir = self.getPath(self.case_dir, False) if not caseDir == None: #type(caseDir) is str or unicode self.foam_case = SolutionDirectory(str(caseDir)) def check_config(self): if not self.foam_case and self.case_dir == "": self.raise_exception("Not set self.case_dir.", RuntimeError) if not os.path.exists(self.foam_case.controlDict()): self.raise_exception("%s is not found. Check self.case_dir." % (self.foam_case.controlDict()), RuntimeError) def _which(self, cmd): """which command with python.""" def is_exe(val): return os.path.isfile(val) and os.access(val, os.X_OK) fpath, fname = os.path.split(cmd) if fpath: if is_exe(cmd): return cmd else: for path in os.environ["PATH"].split(os.pathsep): path = path.strip('"') exe_file = os.path.join(path, cmd) if is_exe(exe_file): return exe_file return None def getPath(self, fdpath, riseError=True): """check and get the absolute path or relative path in $FOAM_RUN.""" if os.path.exists(fdpath): return fdpath bool_foam_run = True foam_run = "" try: foam_run = os.environ['FOAM_RUN'] fpath = os.path.join(foam_run, fdpath) except KeyError: bool_foam_run = False if bool_foam_run and os.path.exists(fpath): return fpath if riseError: self.raise_exception(" '%s' was not found." % fdpath, RuntimeError) return None def _input_trait_modified(self, obj, name, old, new): """hook th changing a trait.""" super(FoamBaseComponent, self)._input_trait_modified(obj, name, old, new) if name == 'case_dir': caseDir = self.getPath(new,False) if not caseDir == None: #type(caseDir) is str or unicode self.foam_case = SolutionDirectory(str(caseDir)) else: self.raise_exception("case_dir '%s' was" " not found." % new, RuntimeError)