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 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):
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):
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)
class Case(object):
"""This class is initialized with a path and gives access to
reporting functions
"""
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")
@property
def sol(self):
"""The actual solution directory"""
return self.__sol
@property
def path(self):
"""The path to the solution"""
return self.__sol.name
@property
def regions(self):
"""Regions in the case"""
return self.__sol.getRegions(defaultRegion=True)
def __callCaseReport(self, region=None, level=3, **kwargs):
"""Helper function that does the actual calling of CaseReport
and returning of the HTML-formatted output"""
s = StringIO()
if region != None:
level = level + 1
CaseReport(args=[self.path],
region=region,
file=s,
headingLevel=level,
**kwargs)
return HTML(
publish_parts(s.getvalue(),
writer_name='html',
settings_overrides={
"initial_header_level": level,
"doctitle_xform": False
})['html_body'])
def size(self, region=None, **kwargs):
return self.__callCaseReport(region=region, caseSize=True, **kwargs)
def boundaryConditions(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
shortBcReport=True,
**kwargs)
def longBoundaryConditions(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
longBcReport=True,
**kwargs)
def dimensions(self, region=None, **kwargs):
return self.__callCaseReport(region=region, dimensions=True, **kwargs)
def internalField(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
internalField=True,
**kwargs)
def linearSolvers(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
linearSolvers=True,
**kwargs)
def relaxationFactors(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
relaxationFactors=True,
**kwargs)
def processorMatrix(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
processorMatrix=True,
**kwargs)
def decomposition(self, region=None, **kwargs):
return self.__callCaseReport(region=region,
decomposition=True,
**kwargs)
def timeline(self, directory, fieldname):
if isinstance(fieldname, string_types):
f = [fieldname]
else:
f = fieldname
return TimelinePlot(args=[self.path],
directoryName=directory,
fields=f,
basicMode="lines",
pandasData=True)["dataFrame"]
def timelineInfo(self, directory):
return TimelinePlot(args=[self.path],
directoryName=directory,
info=True,
silent=True).getData()
def sampleTime(self, directory, line, time):
return SamplePlot(args=[self.path],
directoryName=directory,
line=[line],
time=[time],
fuzzyTime=True,
mode="separate",
pandasData=True)["dataFrame"]
def sampleField(self, directory, line, field):
return SamplePlot(args=[self.path],
directoryName=directory,
line=[line],
field=[field],
mode="separate",
pandasData=True)["dataFrame"]
def sampleInfo(self, directory):
return SamplePlot(args=[self.path],
directoryName=directory,
info=True,
silent=True).getData()
def distributionInfo(self, directory):
return SamplePlot(args=[self.path],
directoryName=directory,
isDistribution=True,
info=True,
silent=True).getData()
def distribution(self, directory, line, time):
return SamplePlot(args=[self.path],
directoryName=directory,
isDistribution=True,
line=[line],
time=[time],
fuzzyTime=True,
mode="separate",
pandasData=True)["dataFrame"]
def pickledPlots(self, pickleFile):
return RedoPlot(args=[path.join(self.path, pickleFile)],
pickleFile=True,
pandasData=True)["plotData"]
def pickledData(self, pickleFile):
return pickle.Unpickler(open(path.join(self.path, pickleFile),
"rb")).load()
def __getObjectName(self, obj):
for ns in get_ipython().all_ns_refs:
for n, v in ns.items():
if obj is v:
if n[0] != "_":
return n
return "unknown"
def __getStorageName(self):
for ns in get_ipython().all_ns_refs:
for n, v in ns.items():
if isinstance(v, PermanentStorage):
return n, v
return None
def timelineSelector(self, directoryName):
info = self.timelineInfo(directoryName)
lst = [widgets.Label(value="Fields:")]
fieldsSelected = set()
storeButton = widgets.Button(description="Store to", disabled=True)
def make_field_toggle(fName):
def f(name, value):
if value:
fieldsSelected.add(fName)
else:
try:
fieldsSelected.remove(fName)
except KeyError:
pass # this should not happen, but hey!
if len(fieldsSelected) > 0:
storeButton.disabled = False
else:
storeButton.disabled = True
return f
for f in info["fields"]:
w = widgets.ToggleButton(description=f)
w.on_trait_change(make_field_toggle(f), 'value')
lst.append(w)
fields = widgets.Box(description="Fields", children=lst)
fields.add_class("hbox")
varName = widgets.Text(description="Variable Name")
def varname_change(name, value):
storeButton.description = "Store to " + value
if len(value) == 0 or len(fieldsSelected) == 0:
storeButton.disabled = True
else:
dis = False
if not value[0].isalpha():
dis = True
storeButton.disabled = dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
v = varName.value
f = list(fieldsSelected)
print_("Storing", f, "from", directoryName, "in", self.path,
"to variable", v)
name = self.__getObjectName(self)
store = self.__getStorageName()
cmd = "%s.timeline('%s',%s)" % (name, directoryName, str(f))
if store:
sname, sval = store
create_code_cell("%s=%s('%s',lambda:%s)" % (v, sname, v, cmd),
"below")
val = sval(v, lambda: self.timeline(directoryName, f))
else:
create_code_cell("%s=%s" % (v, cmd), "below")
val = self.timeline(directoryName, f)
get_ipython().push({v: val})
varName.value = ""
storeButton.on_click(store_clicked)
total = widgets.Box(children=[fields, varName, storeButton])
total.add_class("vbox")
display(total)
def sampleSelector(self, directoryName):
info = self.sampleInfo(directoryName)
mode = widgets.ToggleButtons(description="Mode",
values=["Time", "Field"])
field = widgets.Dropdown(description="Field", values=info["values"])
time = widgets.Dropdown(description="Time", values=info["times"])
# ,value=info["times"][-1])
line = widgets.Dropdown(description="Sample line",
values=info["lines"])
varName = widgets.Text(description="Variable Name")
storeButton = widgets.Button(description="Store to", disabled=True)
def mode_changed(name, value):
if value == "Time":
time.disabled = False
field.disabled = True
else:
time.disabled = True
field.disabled = False
mode.on_trait_change(mode_changed, 'value')
mode_changed('value', mode.value)
def varname_change(name, value):
storeButton.description = "Store to " + value
if len(value) == 0:
storeButton.disabled = True
else:
dis = False
if not value[0].isalpha():
dis = True
storeButton.disabled = dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
l = line.value
v = varName.value
name = self.__getObjectName(self)
store = self.__getStorageName()
if mode.value == "Time":
t = time.value
print_("Storing fields at t=", t, "on line", l, "from",
directoryName, "in", self.path, "to variable", v)
cmdBase = "%s.sampleTime('%s','%s','%s')" % (
name, directoryName, l, t)
if store:
sname, sval = store
cmd = "%s=%s('%s',lambda:%s)" % (v, sname, v, cmdBase)
val = sval(v, lambda: self.sampleTime(directoryName, l, t))
else:
cmd = "%s=%s" % (v, cmdBase)
val = self.sampleTime(directoryName, l, t)
elif mode.value == "Field":
f = field.value
print_("Storing fields", f, " at all times on line", l, "from",
directoryName, "in", self.path, "to variable", v)
cmdBase = "%s.sampleField('%s','%s','%s')" % (
name, directoryName, l, f)
if store:
sname, sval = store
cmd = "%s=%s('%s',lambda:%s)" % (v, sname, v, cmdBase)
val = sval(v,
lambda: self.sampleField(directoryName, l, f))
else:
cmd = "%s=%s" % (v, cmdBase)
val = self.sampleField(directoryName, l, f)
else:
print_("Unknown mode", mode)
return
create_code_cell(cmd, "below")
get_ipython().push({v: val})
varName.value = ""
storeButton.on_click(store_clicked)
total = widgets.Box(
children=[mode, line, field, time, varName, storeButton])
total.add_class("vbox")
display(total)
def distributionSelector(self, directoryName):
info = self.distributionInfo(directoryName)
time = widgets.Dropdown(description="Time",
values=info["times"],
value=info["times"][-1])
line = widgets.Dropdown(description="Sample line",
values=info["lines"])
varName = widgets.Text(description="Variable Name")
storeButton = widgets.Button(description="Store to", disabled=True)
def varname_change(name, value):
storeButton.description = "Store to " + value
if len(value) == 0:
storeButton.disabled = True
else:
dis = False
if not value[0].isalpha():
dis = True
storeButton.disabled = dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
l = line.value
v = varName.value
name = self.__getObjectName(self)
store = self.__getStorageName()
t = time.value
print_("Storing distribution at t=", t, "on line", l, "from",
directoryName, "in", self.path, "to variable", v)
cmd = "%s.distribution('%s','%s','%s')" % (name, directoryName, l,
t)
if store:
sname, sval = store
create_code_cell("%s=%s('%s',lambda:%s)" % (v, sname, v, cmd),
"below")
val = sval(v, lambda: self.distribution(directoryName, l, t))
else:
create_code_cell("%s=%s" % (v, cmd), "below")
val = self.distribution(directoryName, l, t)
get_ipython().push({v: val})
varName.value = ""
storeButton.on_click(store_clicked)
total = widgets.Box(children=[line, time, varName, storeButton])
total.add_class("vbox")
display(total)
def pickledPlotSelector(self):
pPlot = widgets.Dropdown(description="Pickled plot file",
values=self.sol.pickledPlots,
value=self.sol.pickledPlots[0])
varName = widgets.Text(description="Variable Name")
storeButton = widgets.Button(description="Store to", disabled=True)
def varname_change(name, value):
storeButton.description = "Store to " + value
if len(value) == 0:
storeButton.disabled = True
else:
dis = False
if not value[0].isalpha():
dis = True
storeButton.disabled = dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
p = pPlot.value
v = varName.value
name = self.__getObjectName(self)
store = self.__getStorageName()
print_("Storing Pickled Plot data from", p, "to variable", v)
cmd = "%s.pickledPlots('%s')" % (name, p)
if store:
sname, sval = store
create_code_cell("%s=%s('%s',lambda:%s)" % (v, sname, v, cmd),
"below")
val = sval(v, lambda: self.pickledPlots(p))
else:
create_code_cell("%s=%s" % (v, cmd), "below")
val = self.pickledPlots(p)
get_ipython().push({v: val})
varName.value = ""
storeButton.on_click(store_clicked)
total = widgets.Box(children=[pPlot, varName, storeButton])
total.add_class("vbox")
display(total)
def pickledDataSelector(self):
pData = widgets.Dropdown(description="Pickled data file",
values=self.sol.pickledData,
value=self.sol.pickledData[0])
varName = widgets.Text(description="Variable Name")
storeButton = widgets.Button(description="Store to", disabled=True)
def varname_change(name, value):
storeButton.description = "Store to " + value
if len(value) == 0:
storeButton.disabled = True
else:
dis = False
if not value[0].isalpha():
dis = True
storeButton.disabled = dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
p = pData.value
v = varName.value
name = self.__getObjectName(self)
store = self.__getStorageName()
print_("Storing Pickled Data from", p, "to variable", v)
cmd = "%s.pickledData('%s')" % (name, p)
if store:
sname, sval = store
create_code_cell("%s=%s('%s',lambda:%s)" % (v, sname, v, cmd),
"below")
val = sval(v, lambda: self.pickledData(p))
else:
create_code_cell("%s=%s" % (v, cmd), "below")
val = self.pickledData(p)
get_ipython().push({v: val})
varName.value = ""
storeButton.on_click(store_clicked)
total = widgets.Box(children=[pData, varName, storeButton])
total.add_class("vbox")
display(total)
def run(self):
if self.opts.keeppseudo and (not self.opts.regions
and self.opts.region == None):
warning(
"Option --keep-pseudocases only makes sense for multi-region-cases"
)
if self.opts.region:
regionNames = self.opts.region
else:
regionNames = [None]
regions = None
casePath = self.parser.casePath()
self.checkCase(casePath)
# self.addLocalConfig(casePath)
self.addToCaseLog(casePath, "Starting")
self.prepareHooks()
if self.opts.regions or self.opts.region != None:
print_("Building Pseudocases")
sol = SolutionDirectory(casePath, archive=None)
regions = RegionCases(sol, clean=True)
if self.opts.regions:
regionNames = sol.getRegions()
self.processPlotLineOptions(autoPath=casePath)
lam = self.getParallel(SolutionDirectory(casePath, archive=None))
self.clearCase(SolutionDirectory(casePath,
archive=None,
parallel=lam is not None),
runParallel=lam is not None)
self.checkAndCommit(SolutionDirectory(casePath, archive=None))
self.initBlink()
for theRegion in regionNames:
args = self.buildRegionArgv(casePath, theRegion)
self.setLogname()
run = AnalyzedRunner(BoundingLogAnalyzer(
progress=self.opts.progress,
doFiles=self.opts.writeFiles,
singleFile=self.opts.singleDataFilesOnly,
doTimelines=True),
silent=self.opts.progress or self.opts.silent,
splitThres=self.opts.splitDataPointsThreshold
if self.opts.doSplitDataPoints else None,
argv=self.replaceAutoInArgs(args),
server=self.opts.server,
lam=lam,
restart=self.opts.restart,
logname=self.opts.logname,
compressLog=self.opts.compress,
logTail=self.opts.logTail,
noLog=self.opts.noLog,
remark=self.opts.remark,
parameters=self.getRunParameters(),
echoCommandLine=self.opts.echoCommandPrefix,
jobId=self.opts.jobId)
run.createPlots(customRegexp=self.lines_,
splitThres=self.opts.splitDataPointsThreshold
if self.opts.doSplitDataPoints else None,
writeFiles=self.opts.writeFiles)
if self.cursesWindow:
self.cursesWindow.setAnalyzer(run.analyzer)
self.cursesWindow.setRunner(run)
run.analyzer.addTimeListener(self.cursesWindow)
self.addWriteAllTrigger(run,
SolutionDirectory(casePath, archive=None))
self.addLibFunctionTrigger(
run, SolutionDirectory(casePath, archive=None))
self.runPreHooks()
if self.blink1:
run.addTicker(lambda: self.blink1.ticToc())
run.start()
if len(regionNames) > 1:
self.setData({theRegion: run.data})
else:
self.setData(run.data)
self.runPostHooks()
self.reportUsage(run)
self.reportRunnerData(run)
if theRegion != None:
print_("Syncing into master case")
regions.resync(theRegion)
self.stopBlink()
if regions != None:
if not self.opts.keeppseudo:
print_("Removing pseudo-regions")
regions.cleanAll()
else:
for r in sol.getRegions():
if r not in regionNames:
regions.clean(r)
self.addToCaseLog(casePath, "Ended")
def run(self):
if self.cmdname in ["create","copy"]:
if self.cmdname=="create":
dest=self.parser.getArgs()[0]
else:
dest=self.parser.getArgs()[1]
sol=SolutionDirectory(dest,
paraviewLink=False,
archive=None)
fName=path.join(sol.name,path.basename(sol.name)+".ipynb")
if self.opts.destinationFile:
fName=self.opts.destinationFile
if path.isdir(fName):
fName=path.join(fName,path.basename(sol.name))
if path.splitext(fName)[1]!=".ipynb":
fName+=".ipynb"
if self.opts.absolutePath:
usedDest=sol.name
else:
usedDest=path.relpath(sol.name,
start=path.dirname(path.abspath(
fName)))
if path.exists(fName):
if not self.opts.forceWrite:
self.error("File",fName,"already existing")
else:
self.warning("Overwriting",fName)
nb=Notebook(name=path.basename(sol.name))
nb.pyFoamMetaData()["description"]="Created by "+self.parser.get_prog_name()
if self.cmdname=="create":
nb.addHeading("Imports and administrative stuff",
level=1,classes="heading")
if self.opts.developerMode:
nb.addMarkdown("This part only needed by developers (reload imports)",
classes=("comment","developer"))
nb.addCode("%load_ext autoreload",classes="developer")
nb.addCode("%autoreload 2",classes="developer")
nb.addMarkdown("Make sure that plots are inlined",
classes="comment")
nb.addCode("%matplotlib inline")
if self.opts.additional:
nb.addHeading("Additional imports for convenience",
level=2,classes=("heading","additional"))
nb.addMarkdown("Allow panning and zooming in plots. Slower than regular plotting so for big data you might want to use `mpld3.disable_notebook()` and erase this cell.",
classes=("comment","additional"))
nb.addCode(
"""try:
import mpld3
mpld3.enable_notebook()
except ImportError:
print 'No mpld3-library. No interactive plots'""",classes="additional")
nb.addMarkdown(
"""Wrapper with additional functionality to the regular Pandas-`DataFrame`:
* `addData()` for adding columns from other data sets (with resampling
* `integrals()` and `weightedAverage()`. Also extended `descripe()` that returns this data
Most Pandas-operations (like slicing) will return a Pandas-`DataFrame`. By enclosing this in `DataFrame(...)` you can 'add' this functionality to your data. PyFoam operations return this extended `DataFrame` automatically""",
classes=("comment","additional"))
nb.addCode("from PyFoam.Wrappers.Pandas import PyFoamDataFrame as DataFrame",classes="additional")
nb.addHeading("Data storage",
level=2,classes=("heading"))
nb.addMarkdown("This is the support for permanently storing data into the notebook",
classes="comment")
nb.addCode("from PyFoam.IPython import storage")
nb.addMarkdown("Due to technical problems the next line has to be executed 'by hand' (it will not work poperly if called from `Run All` or similar). When reopening the page the JavaScript-error is normal (it will go away once the cell is executed). Reading can take some time and the next command will appear to 'hang'",
classes="comment")
nb.addCode("store=storage()")
nb.addMarkdown("The next line switches on the behaviour that items specified with `store(name,func)` will be stored permanently in the notebook. Uncomment if you want this behaviour",
classes="comment")
nb.addCode("# store.autowriteOn()")
nb.addMarkdown("The next line switches off the default behaviour that for items specified with `store(name,func)` if `name` is already specified in the permant storage this value is used and `func` is ignored",
classes="comment")
nb.addCode("# store.autoreadOff()")
nb.addHeading("Case data",
level=2,classes=("heading"))
nb.addMarkdown("This class makes it easy to access case data. Use tab-completion for available methods",
classes="comment")
nb.addCode("from PyFoam.IPython.Case import Case")
nb.addHeading("The Case",classes="heading")
v=self.opts.caseVariable
nb.addCode("%s=Case('%s')" % (v,usedDest),classes="case",
pyFoam={"caseVar":v,"usedDirectory":usedDest,
"casePath":sol.name})
if self.opts.caseReport:
nb.addHeading("Case Report",level=2,
classes=("report","heading"))
regions=sorted(sol.getRegions(defaultRegion=True))
namedRegions=[r for r in regions if r!=None]
if len(namedRegions)>0:
nb.addMarkdown("Contains named regions *"+
", ".join(namedRegions)+"*",
classes=("info","report"))
if sol.procNr>0:
nb.addMarkdown("Case seems to be decomposed to "+
str(sol.procNr)+" processors",
classes=("info","report"))
for region in regions:
if region==None:
level=3
regionStr=""
else:
nb.addHeading("Region "+region,
level=3,classes=("heading","report"))
level=4
regionStr="region='%s'," % region
nb.addCode("%s.size(%slevel=%d)" % (v,regionStr,level),
classes="report")
nb.addCode("%s.boundaryConditions(%slevel=%d)" % (v,regionStr,level),
classes="report")
nb.addCode("%s.dimensions(%slevel=%d)" % (v,regionStr,level),
classes="report")
nb.addCode("%s.internalField(%slevel=%d)" % (v,regionStr,level),
classes="report")
if self.opts.longBCs:
nb.addCode("%s.longBoundaryConditions(%slevel=%d)" % (regionStr,v,level),
classes="report")
if sol.procNr>0 and self.opts.parallelReport:
nb.addCode("%s.decomposition(%slevel=%d)" % (v,regionStr,level),
classes="report")
nb.addCode("%s.processorMatrix(%slevel=%d)" % (v,regionStr,level),
classes="report")
if self.opts.postprocessing:
nb.addHeading("Postprocessing data",classes="heading")
if len(sol.timelines)>0:
nb.addMarkdown("Timelines",classes="info")
nb.addCode("%s.sol.timelines" % v,classes="info")
if len(sol.samples)>0:
nb.addMarkdown("Samples",classes="info")
nb.addCode("%s.sol.samples" % v,classes="info")
if len(sol.surfaces)>0:
nb.addMarkdown("Surfaces",classes="info")
nb.addCode("%s.sol.surfaces" % v,classes="info")
if len(sol.distributions)>0:
nb.addMarkdown("Distributions",classes="info")
nb.addCode("%s.sol.distributions" % v,classes="info")
if len(sol.pickledData)>0:
nb.addMarkdown("Pickled data files",classes="info")
nb.addCode("%s.sol.pickledData" % v,classes="info")
if len(sol.pickledPlots)>0:
nb.addMarkdown("Pickled plot files",classes="info")
nb.addCode("%s.sol.pickledPlots" % v,classes="info")
if self.opts.selectors:
sel=[("timeline",sol.timelines),
("sample",sol.samples),
("distribution",sol.distributions)]
for desc,items in sel:
if len(items)>0:
nb.addHeading(desc.capitalize()+
" selectors",level=3,
classes=("heading","selector"))
for i in items:
nb.addCode("%s.%sSelector('%s')" %
(v,desc,i),
classes="selector")
if len(sol.pickledPlots)>0 or len(sol.pickledData)>0:
nb.addHeading("Data selectors",level=3,
classes=("heading","selector"))
if len(sol.pickledPlots)>0:
nb.addCode("%s.pickledPlotSelector()" % v,classes="selector")
if len(sol.pickledData)>0:
nb.addCode("%s.pickledDataSelector()" % v,classes="selector")
nb.addHeading("User evaluations",classes="heading")
nb.addMarkdown("Now add your own stuff",classes="comment")
elif self.cmdname=="copy":
src=self.parser.getArgs()[0]
nb=Notebook(src)
cnt=0
for c in nb:
if c.isClass("case"):
cnt+=1
if cnt>1:
self.error(src,"has more than one 'case'-cell")
py=c.meta()[u("pyFoam")]
used=py["usedDirectory"]
input=[]
changed=False
for l in c["input"]:
if l.find(used)>=0:
input.append(l.replace(used,usedDest))
changed=True
else:
input.append(l)
if not changed:
self.warning(used,"not found")
py["usedDirectory"]=usedDest
py["casePath"]=sol.name
c["input"]=input
else:
self.error("Unimplemented:",self.cmdname)
nb.writeToFile(fName)
elif self.cmdname=="info":
for n in self.parser.getArgs():
print_(n)
print_("-"*len(n))
nb=Notebook(n)
meta=nb.pyFoamMetaData()
try:
origin=meta["createdBy"]
except KeyError:
origin="unknown"
try:
created=meta["createdTime"]
except KeyError:
created="unknown"
try:
created=meta["createdTime"]
except KeyError:
created="unknown"
try:
modified=meta["modificationTime"]
except KeyError:
modified="unknown"
print_("Created by",origin,"at",created,
"modified",modified)
classes={}
cases={}
nrOutput=0
for c in nb:
if "outputs" in c:
if len(c["outputs"])>0:
nrOutput+=1
try:
py=c.meta()[u("pyFoam")]
except KeyError:
continue
try:
cl=py["classes"]
for c in cl:
try:
classes[c]+=1
except KeyError:
classes[c]=1
except KeyError:
pass
if "caseVar" in py:
try:
cases[py["caseVar"]]=py["casePath"]
except KeyError:
pass
print_(len(nb),"cells. Classes:",
", ".join([k+":"+str(classes[k]) for k in sorted(classes.keys())]))
print_("Cells with output:",nrOutput)
print("Case-Variables:")
for k in sorted(cases.keys()):
print_(" ",k,":",cases[k])
print_()
elif self.cmdname=="clean":
nb=Notebook(self.parser.getArgs()[0])
if not self.opts.overwrite and not self.opts.outfile:
self.error("Either specify --overwrite or --outfile")
if self.opts.overwrite and self.opts.outfile:
self.error("Only specify --overwrite or --outfile")
if self.opts.outfile:
if path.exists(self.opts.outfile):
if not self.opts.force:
self.error("File",self.opts.outfile,"exists")
else:
self.warning("Overwriting",self.opts.outfile)
else:
if path.splitext(self.opts.outfile)[1]!=".ipynb":
self.warning("Appending '.ipynb' to",self.opts.outfile)
self.opts.outfile+=".ipynb"
if self.opts.overwrite:
toFile=self.parser.getArgs()[0]
else:
toFile=self.opts.outfile
removeClasses=self.opts.customTags[:]
if self.opts.cleanSelector:
removeClasses.append("selector")
if self.opts.cleanDeveloper:
removeClasses.append("developer")
if self.opts.cleanHeading:
removeClasses.append("heading")
if self.opts.cleanComment:
removeClasses.append("comment")
if self.opts.cleanReport:
removeClasses.append("report")
if self.opts.cleanInfo:
removeClasses.append("info")
print_("Cleaning cells tagged with: "+" ".join(sorted(removeClasses)))
nb.reset([c for c in nb if not c.isClass(removeClasses)])
if self.opts.cleanOutput:
print_("Removing output")
for c in nb:
if "outputs" in c:
c["outputs"]=[]
nb.writeToFile(toFile)
else:
self.error("Unimplemented command",self.cmdname)
class Case(object):
"""This class is initialized with a path and gives access to
reporting functions
"""
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")
@property
def sol(self):
"""The actual solution directory"""
return self.__sol
@property
def path(self):
"""The path to the solution"""
return self.__sol.name
@property
def regions(self):
"""Regions in the case"""
return self.__sol.getRegions(defaultRegion=True)
def __callCaseReport(self,region=None,level=3,**kwargs):
"""Helper function that does the actual calling of CaseReport
and returning of the HTML-formatted output"""
s=StringIO()
if region!=None:
level=level+1
CaseReport(args=[self.path],
region=region,
file=s,
headingLevel=level,
**kwargs)
return HTML(publish_parts(s.getvalue(),
writer_name='html',
settings_overrides={
"initial_header_level":level,
"doctitle_xform":False
})['html_body'])
def size(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
caseSize=True,
**kwargs)
def boundaryConditions(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
shortBcReport=True,
**kwargs)
def longBoundaryConditions(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
longBcReport=True,
**kwargs)
def dimensions(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
dimensions=True,
**kwargs)
def internalField(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
internalField=True,
**kwargs)
def linearSolvers(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
linearSolvers=True,
**kwargs)
def relaxationFactors(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
relaxationFactors=True,
**kwargs)
def processorMatrix(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
processorMatrix=True,
**kwargs)
def decomposition(self,region=None,**kwargs):
return self.__callCaseReport(region=region,
decomposition=True,
**kwargs)
def timeline(self,directory,fieldname):
if isinstance(fieldname,string_types):
f=[fieldname]
else:
f=fieldname
return TimelinePlot(args=[self.path],
directoryName=directory,
fields=f,
basicMode="lines",
pandasData=True)["dataFrame"]
def timelineInfo(self,directory):
return TimelinePlot(args=[self.path],
directoryName=directory,
info=True,
silent=True).getData()
def sampleTime(self,directory,line,time):
return SamplePlot(args=[self.path],
directoryName=directory,
line=[line],
time=[time],
fuzzyTime=True,
mode="separate",
pandasData=True)["dataFrame"]
def sampleField(self,directory,line,field):
return SamplePlot(args=[self.path],
directoryName=directory,
line=[line],
field=[field],
mode="separate",
pandasData=True)["dataFrame"]
def sampleInfo(self,directory):
return SamplePlot(args=[self.path],
directoryName=directory,
info=True,
silent=True).getData()
def distributionInfo(self,directory):
return SamplePlot(args=[self.path],
directoryName=directory,
isDistribution=True,
info=True,
silent=True).getData()
def distribution(self,directory,line,time):
return SamplePlot(args=[self.path],
directoryName=directory,
isDistribution=True,
line=[line],
time=[time],
fuzzyTime=True,
mode="separate",
pandasData=True)["dataFrame"]
def pickledPlots(self,pickleFile):
return RedoPlot(
args=[path.join(self.path,pickleFile)],
pickleFile=True,
pandasData=True)["plotData"]
def pickledData(self,pickleFile):
return pickle.Unpickler(open(path.join(self.path,pickleFile),"rb")).load()
def __getObjectName(self,obj):
for ns in get_ipython().all_ns_refs:
for n,v in ns.items():
if obj is v:
if n[0]!="_":
return n
return "unknown"
def __getStorageName(self):
for ns in get_ipython().all_ns_refs:
for n,v in ns.items():
if isinstance(v,PermanentStorage):
return n,v
return None
def timelineSelector(self,directoryName):
info=self.timelineInfo(directoryName)
lst=[widgets.LatexWidget(value="Fields:")]
fieldsSelected=set()
storeButton=widgets.ButtonWidget(description="Store to",disabled=True)
def make_field_toggle(fName):
def f(name,value):
if value:
fieldsSelected.add(fName)
else:
try:
fieldsSelected.remove(fName)
except KeyError:
pass # this should not happen, but hey!
if len(fieldsSelected)>0:
storeButton.disabled=False
else:
storeButton.disabled=True
return f
for f in info["fields"]:
w=widgets.ToggleButtonWidget(description=f)
w.on_trait_change(make_field_toggle(f), 'value')
lst.append(w)
fields=widgets.ContainerWidget(description="Fields",children=lst)
fields.add_class("hbox")
varName=widgets.TextWidget(description="Variable Name")
def varname_change(name,value):
storeButton.description="Store to "+value
if len(value)==0 or len(fieldsSelected)==0:
storeButton.disabled=True
else:
dis=False
if not value[0].isalpha():
dis=True
storeButton.disabled=dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
v=varName.value
f=list(fieldsSelected)
print_("Storing",f,"from",directoryName,"in",self.path,"to variable",v)
name=self.__getObjectName(self)
store=self.__getStorageName()
cmd="%s.timeline('%s',%s)" % (name,directoryName,str(f))
if store:
sname,sval=store
create_code_cell(
"%s=%s('%s',lambda:%s)" % (v,sname,v,cmd),
"below")
val=sval(v,lambda:self.timeline(directoryName,f))
else:
create_code_cell(
"%s=%s" % (v,cmd),
"below")
val=self.timeline(directoryName,f)
get_ipython().push({v:val})
varName.value=""
storeButton.on_click(store_clicked)
total=widgets.ContainerWidget(children=[fields,varName,storeButton])
total.add_class("vbox")
display(total)
def sampleSelector(self,directoryName):
info=self.sampleInfo(directoryName)
mode=widgets.ToggleButtonsWidget(description="Mode",values=["Time","Field"])
field=widgets.DropdownWidget(description="Field",values=info["values"])
time=widgets.DropdownWidget(description="Time",values=info["times"],value=info["times"][-1])
line=widgets.DropdownWidget(description="Sample line",values=info["lines"])
varName=widgets.TextWidget(description="Variable Name")
storeButton=widgets.ButtonWidget(description="Store to",disabled=True)
def mode_changed(name,value):
if value=="Time":
time.disabled=False
field.disabled=True
else:
time.disabled=True
field.disabled=False
mode.on_trait_change(mode_changed,'value')
mode_changed('value',mode.value)
def varname_change(name,value):
storeButton.description="Store to "+value
if len(value)==0:
storeButton.disabled=True
else:
dis=False
if not value[0].isalpha():
dis=True
storeButton.disabled=dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
l=line.value
v=varName.value
name=self.__getObjectName(self)
store=self.__getStorageName()
if mode.value=="Time":
t=time.value
print_("Storing fields at t=",t,"on line",l,"from",directoryName,"in",self.path,"to variable",v)
cmdBase="%s.sampleTime('%s','%s','%s')" % (name,directoryName,l,t)
if store:
sname,sval=store
cmd="%s=%s('%s',lambda:%s)" % (v,sname,v,cmdBase)
val=sval(v,lambda:self.sampleTime(directoryName,l,t))
else:
cmd="%s=%s" % (v,cmdBase)
val=self.sampleTime(directoryName,l,t)
elif mode.value=="Field":
f=field.value
print_("Storing fields",f," at all times on line",l,"from",directoryName,"in",self.path,"to variable",v)
cmdBase="%s.sampleField('%s','%s','%s')" % (name,directoryName,l,f)
if store:
sname,sval=store
cmd="%s=%s('%s',lambda:%s)" % (v,sname,v,cmdBase)
val=sval(v,lambda:self.sampleField(directoryName,l,f))
else:
cmd="%s=%s" % (v,cmdBase)
val=self.sampleField(directoryName,l,f)
else:
print_("Unknown mode",mode)
return
create_code_cell(cmd,"below")
get_ipython().push({v:val})
varName.value=""
storeButton.on_click(store_clicked)
total=widgets.ContainerWidget(children=[mode,line,field,time,varName,storeButton])
total.add_class("vbox")
display(total)
def distributionSelector(self,directoryName):
info=self.distributionInfo(directoryName)
time=widgets.DropdownWidget(description="Time",values=info["times"],value=info["times"][-1])
line=widgets.DropdownWidget(description="Sample line",values=info["lines"])
varName=widgets.TextWidget(description="Variable Name")
storeButton=widgets.ButtonWidget(description="Store to",disabled=True)
def varname_change(name,value):
storeButton.description="Store to "+value
if len(value)==0:
storeButton.disabled=True
else:
dis=False
if not value[0].isalpha():
dis=True
storeButton.disabled=dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
l=line.value
v=varName.value
name=self.__getObjectName(self)
store=self.__getStorageName()
t=time.value
print_("Storing distribution at t=",t,"on line",l,"from",directoryName,"in",self.path,"to variable",v)
cmd="%s.distribution('%s','%s','%s')" % (name,directoryName,l,t)
if store:
sname,sval=store
create_code_cell(
"%s=%s('%s',lambda:%s)" % (v,sname,v,cmd),
"below")
val=sval(v,lambda:self.distribution(directoryName,l,t))
else:
create_code_cell(
"%s=%s" % (v,cmd),
"below")
val=self.distribution(directoryName,l,t)
get_ipython().push({v:val})
varName.value=""
storeButton.on_click(store_clicked)
total=widgets.ContainerWidget(children=[line,time,varName,storeButton])
total.add_class("vbox")
display(total)
def pickledPlotSelector(self):
pPlot=widgets.DropdownWidget(description="Pickled plot file",
values=self.sol.pickledPlots,
value=self.sol.pickledPlots[0])
varName=widgets.TextWidget(description="Variable Name")
storeButton=widgets.ButtonWidget(description="Store to",disabled=True)
def varname_change(name,value):
storeButton.description="Store to "+value
if len(value)==0:
storeButton.disabled=True
else:
dis=False
if not value[0].isalpha():
dis=True
storeButton.disabled=dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
p=pPlot.value
v=varName.value
name=self.__getObjectName(self)
store=self.__getStorageName()
print_("Storing Pickled Plot data from",p,"to variable",v)
cmd="%s.pickledPlots('%s')" % (name,p)
if store:
sname,sval=store
create_code_cell(
"%s=%s('%s',lambda:%s)" % (v,sname,v,cmd),
"below")
val=sval(v,lambda:self.pickledPlots(p))
else:
create_code_cell(
"%s=%s" % (v,cmd),
"below")
val=self.pickledPlots(p)
get_ipython().push({v:val})
varName.value=""
storeButton.on_click(store_clicked)
total=widgets.ContainerWidget(children=[pPlot,varName,storeButton])
total.add_class("vbox")
display(total)
def pickledDataSelector(self):
pData=widgets.DropdownWidget(description="Pickled data file",
values=self.sol.pickledData,
value=self.sol.pickledData[0])
varName=widgets.TextWidget(description="Variable Name")
storeButton=widgets.ButtonWidget(description="Store to",disabled=True)
def varname_change(name,value):
storeButton.description="Store to "+value
if len(value)==0:
storeButton.disabled=True
else:
dis=False
if not value[0].isalpha():
dis=True
storeButton.disabled=dis
varName.on_trait_change(varname_change, 'value')
def store_clicked(b):
p=pData.value
v=varName.value
name=self.__getObjectName(self)
store=self.__getStorageName()
print_("Storing Pickled Data from",p,"to variable",v)
cmd="%s.pickledData('%s')" % (name,p)
if store:
sname,sval=store
create_code_cell(
"%s=%s('%s',lambda:%s)" % (v,sname,v,cmd),
"below")
val=sval(v,lambda:self.pickledData(p))
else:
create_code_cell(
"%s=%s" % (v,cmd),
"below")
val=self.pickledData(p)
get_ipython().push({v:val})
varName.value=""
storeButton.on_click(store_clicked)
total=widgets.ContainerWidget(children=[pData,varName,storeButton])
total.add_class("vbox")
display(total)
def run(self):
if self.opts.keeppseudo and (not self.opts.regions and self.opts.region==None):
warning("Option --keep-pseudocases only makes sense for multi-region-cases")
if self.opts.region:
regionNames=self.opts.region
else:
regionNames=[None]
regions=None
casePath=self.parser.casePath()
self.checkCase(casePath)
# self.addLocalConfig(casePath)
self.addToCaseLog(casePath,"Starting")
self.prepareHooks()
if self.opts.regions or self.opts.region!=None:
print_("Building Pseudocases")
sol=SolutionDirectory(casePath,archive=None)
regions=RegionCases(sol,clean=True)
if self.opts.regions:
regionNames=sol.getRegions()
self.processPlotLineOptions(autoPath=casePath)
self.clearCase(SolutionDirectory(casePath,archive=None))
lam=self.getParallel(SolutionDirectory(casePath,archive=None))
self.checkAndCommit(SolutionDirectory(casePath,archive=None))
for theRegion in regionNames:
args=self.buildRegionArgv(casePath,theRegion)
self.setLogname()
run=AnalyzedRunner(BoundingLogAnalyzer(progress=self.opts.progress,
doFiles=self.opts.writeFiles,
singleFile=self.opts.singleDataFilesOnly,
doTimelines=True),
silent=self.opts.progress or self.opts.silent,
argv=args,
server=self.opts.server,
lam=lam,
restart=self.opts.restart,
logname=self.opts.logname,
compressLog=self.opts.compress,
logTail=self.opts.logTail,
noLog=self.opts.noLog,
remark=self.opts.remark,
parameters=self.getRunParameters(),
echoCommandLine=self.opts.echoCommandPrefix,
jobId=self.opts.jobId)
run.createPlots(customRegexp=self.lines_,
writeFiles=self.opts.writeFiles)
self.addWriteAllTrigger(run,SolutionDirectory(casePath,archive=None))
self.addLibFunctionTrigger(run,SolutionDirectory(casePath,archive=None))
self.runPreHooks()
run.start()
if len(regionNames)>1:
self.setData({theRegion:run.data})
else:
self.setData(run.data)
self.runPostHooks()
self.reportUsage(run)
self.reportRunnerData(run)
if theRegion!=None:
print_("Syncing into master case")
regions.resync(theRegion)
if regions!=None:
if not self.opts.keeppseudo:
print_("Removing pseudo-regions")
regions.cleanAll()
else:
for r in sol.getRegions():
if r not in regionNames:
regions.clean(r)
self.addToCaseLog(casePath,"Ended")
