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 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(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 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):
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):
if len(self.parser.getArgs())>2:
error("Too many arguments:",self.parser.getArgs()[2:],"can not be used")
sName=self.parser.getArgs()[0]
dName=self.parser.getArgs()[1]
if path.exists(dName):
if self.parser.getOptions().force:
warning("Replacing",dName,"(--force option)")
elif path.exists(path.join(dName,"system","controlDict")):
error("Destination",dName,"already existing and a Foam-Case")
elif path.isdir(dName):
dName=path.join(dName,path.basename(sName))
if path.exists(dName) and not self.parser.getOptions().force:
error(dName,"already existing")
elif not path.exists(path.dirname(dName)):
warning("Directory",path.dirname(dName),"does not exist. Creating")
sol=SolutionDirectory(sName,
archive=None,
paraviewLink=False,
addLocalConfig=True,
parallel=self.opts.parallel)
if sol.determineVCS()!=None and self.opts.vcs:
if self.opts.chemkin or self.opts.additional or self.opts.latest:
self.error("Using an unimplemented option together with VCS")
vcsInter=getVCS(sol.determineVCS(),
path=sol.name)
vcsInter.clone(dName)
return
if self.parser.getOptions().chemkin:
sol.addToClone("chemkin")
if self.parser.getOptions().dopyfoam:
sol.addToClone("customRegexp")
for a in self.parser.getOptions().additional:
sol.addToClone(a)
if self.parser.getOptions().latest:
sol.addToClone(sol.getLast())
if self.opts.symlinkMode:
sol.symlinkCase(
dName,
followSymlinks=self.parser.getOptions().followSymlinks,
maxLevel=self.opts.symlinkLevel,
relPath=self.opts.symlinkRelative
)
else:
sol.cloneCase(
dName,
followSymlinks=self.parser.getOptions().followSymlinks
)
self.addToCaseLog(dName,"Cloned to",dName)
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 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 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 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 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 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 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 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 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 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 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 testTimeDirectoryAdding(self):
test = SolutionDirectory(self.theFile)["0"]
self.assertEqual(len(test), 4)
test["U2"] = test["U"]
self.assertEqual(len(test), 5)
test["nix"] = 23
self.assertEqual(len(test), 6)
del test["nix"]
self.assertEqual(len(test), 5)
del test["U2"]
self.assertEqual(len(test), 4)
def run(self):
cName = self.parser.casePath()
times = self.processTimestepOptions(
SolutionDirectory(cName, archive=None))
if len(times) < 1:
self.warning("Can't continue without time-steps")
return
lam = self.getParallel(SolutionDirectory(cName, archive=None))
data = []
for i, t in enumerate(times):
print_(" Running for t=", t)
run = UtilityRunner(
argv=self.parser.getArgs() + ["-time", t],
silent=self.opts.progress or self.opts.silent,
server=self.opts.server,
logname="%s.%s.t=%s" %
(self.opts.logname, self.parser.getApplication(), t),
compressLog=self.opts.compress,
logTail=self.opts.logTail,
noLog=self.opts.noLog,
echoCommandLine=self.opts.echoCommandPrefix,
lam=lam)
self.addToCaseLog(cName, "Starting for t=%s", t)
run.start()
self.setData({t: run.data})
self.addToCaseLog(cName, "Ending")
self.reportUsage(run)
self.reportRunnerData(run)
data.append(run.data)
return data
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):
cName = self.parser.casePath()
self.checkCase(cName)
sol = SolutionDirectory(cName, archive=None)
print_("Clearing out old timesteps ....")
sol.clearResults()
self.checkAndCommit(SolutionDirectory(cName, archive=None))
run = BasicRunner(argv=self.parser.getArgs(),
server=self.opts.server,
logname="PyFoamMeshUtility")
self.addLibFunctionTrigger(run, sol)
self.addToCaseLog(cName, "Starting")
run.start()
self.setData(run.data)
sol.reread(force=True)
self.addToCaseLog(cName, "Ending")
if sol.latestDir() != sol.initialDir():
for f in listdir(path.join(sol.latestDir(), "polyMesh")):
system("mv -f " + path.join(sol.latestDir(), "polyMesh", f) +
" " + sol.polyMeshDir())
print_("\nClearing out new timesteps ....")
sol.clearResults()
else:
print_("\n\n No new timestep. Utility propably failed")
def setUp(self):
self.dest = mktemp()
SolutionDirectory(damBreakTutorial(), archive=None,
paraviewLink=False).cloneCase(self.dest)
if oldApp():
pathSpec = [path.dirname(self.dest), path.basename(self.dest)]
else:
pathSpec = ["-case", self.dest]
run = UtilityRunner(argv=["blockMesh"] + pathSpec,
silent=False,
server=False)
run.start()
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 testTimeDirectoryBasicContainerStuff(self):
test = SolutionDirectory(self.theFile)["0"]
self.assertEqual(len(test), 4)
self.assert_(gammaName() in test)
self.assert_("nix" not in test)
tf = test["U"]
self.assertEqual(type(tf), SolutionFile)
self.assert_(FileBasis in tf.__class__.__mro__)
self.assertRaises(KeyError, test.__getitem__, "nix")
self.assertRaises(TypeError, test.__getitem__, 42)
lst = []
for v in test:
lst.append(v.baseName())
self.assert_(gammaName() in lst)
self.assertEqual(len(lst), len(test))
