def createPlotTimelines(timelines,
custom,
implementation=None,
gnuplotTerminal=None,
showWindow=True,
registry=None):
"""Creates a plotting object
:param timelines: The timelines object
:type timelines: TimeLineCollection
:param custom: specifies how the block should look like
:param implementation: the implementation that should be used
"""
if implementation==None:
implementation=configuration().get("Plotting","preferredImplementation")
if implementation not in lookupTable:
error("Requested plotting implementation",implementation,
"not in list of available implementations",list(lookupTable.keys()))
options={
"showWindow" : showWindow,
"registry" : registry
}
if implementation=="gnuplot":
if not gnuplotTerminal:
gnuplotTerminal=configuration().get("Plotting","gnuplot_terminal")
if gnuplotTerminal not in validTerminals():
error("Terminal",gnuplotTerminal,"not in list of valid terminals",
", ".join(validTerminals()))
options["terminal"]=gnuplotTerminal
return lookupTable[implementation](timelines,
custom,
**options)
def checkAndCreateHookInstances(self, toDict, prefix):
for h in self.getHooksWithPrefix(prefix):
self.hookmessage("Checking", h)
if configuration().getboolean(h, "enabled", default=True):
subdict = {}
mod = configuration().get(h, "module", default="")
if mod == "":
self.warning("No module specified for", h)
continue
subdict["minRunTime"] = configuration().getfloat(h,
"minRunTime",
default=-1)
subdict["stopOnError"] = configuration().getboolean(
h, "stopOnError", default=False)
self.hookmessage("Trying to import", mod)
try:
try:
module = __import__(mod, globals(), locals(),
["dummy"])
except ImportError:
e = sys.exc_info(
)[1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("ImportError:", e)
mod = "PyFoam.Infrastructure.RunHooks." + mod
self.hookmessage("Trying to import", mod)
try:
module = __import__(mod, globals(), locals(),
["dummy"])
except ImportError:
self.hookmessage("ImportError:", e)
self.warning("Could not import module",
mod.split(".")[-1], "for", h,
"(Tried", mod, "too)")
continue
except SyntaxError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("SyntaxError:", e)
self.warning("Syntax error when trying to import", mod)
continue
try:
theClass = getattr(module, mod.split(".")[-1])
except AttributeError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("AttributeError:", e)
self.hookmessage("Attributes:", dir(module))
self.warning("Class",
mod.split(".")[-1], "missing form", mod)
continue
try:
subdict["instance"] = theClass(self, h)
except Exception:
self.warning("Problem while creating instance of",
theClass, ":", traceback.format_exc())
self.stopExecutionOnHookError(subdict["stopOnError"])
continue
toDict[h] = subdict
else:
self.hookmessage(h, "is disabled")
def addLocalConfig(self, directory=None):
"""
Adds a local directory (assuming it is found)
"""
if directory != None:
configuration().addFile(path.join(directory, "LocalConfigPyFoam"),
silent=True)
def createPlotTimelines(timelines,
custom,
implementation=None,
gnuplotTerminal=None,
showWindow=True,
quiet=False,
registry=None):
"""Creates a plotting object
:param timelines: The timelines object
:type timelines: TimeLineCollection
:param custom: specifies how the block should look like
:param implementation: the implementation that should be used
"""
if implementation == None:
implementation = configuration().get("Plotting",
"preferredImplementation")
if implementation not in lookupTable:
error("Requested plotting implementation", implementation,
"not in list of available implementations",
list(lookupTable.keys()))
options = {"showWindow": showWindow, "quiet": quiet, "registry": registry}
if implementation == "gnuplot":
if not gnuplotTerminal:
gnuplotTerminal = configuration().get("Plotting",
"gnuplot_terminal")
if gnuplotTerminal not in validTerminals():
error("Terminal", gnuplotTerminal,
"not in list of valid terminals",
", ".join(validTerminals()))
options["terminal"] = gnuplotTerminal
return lookupTable[implementation](timelines, custom, **options)
def checkAndCreateHookInstances(self,toDict,prefix):
for h in self.getHooksWithPrefix(prefix):
self.hookmessage("Checking",h)
if configuration().getboolean(h,"enabled",default=True):
subdict={}
modName=configuration().get(h,"module",default="")
if modName=="":
self.warning("No module specified for",h)
continue
subdict["minRunTime"]=configuration().getfloat(h,
"minRunTime",
default=-1)
subdict["stopOnError"]=configuration().getboolean(h,
"stopOnError",
default=False)
self.hookmessage("Trying to import",modName)
module=None
modNames=[modName,
"PyFoam.Site."+modName,
"PyFoam.Infrastructure.RunHooks."+modName]
for mod in modNames:
try:
self.hookmessage("Trying module:",mod)
module=__import__(mod,globals(),locals(),["dummy"])
self.hookmessage("Got module:",mod)
break
except ImportError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("ImportError:",e,"for",modName)
except SyntaxError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("SyntaxError:",e)
self.warning("Syntax error when trying to import",mod)
break
if module is None:
self.warning("Could not import module",modName,
"for",h,"(Tried",", ".join(modNames),")")
continue
try:
theClass=getattr(module,mod.split(".")[-1])
except AttributeError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
self.hookmessage("AttributeError:",e)
self.hookmessage("Attributes:",dir(module))
self.warning("Class",mod.split(".")[-1],"missing form",
mod)
continue
try:
subdict["instance"]=theClass(self,h)
except Exception:
self.warning("Problem while creating instance of",
theClass,":",traceback.format_exc())
self.stopExecutionOnHookError(subdict["stopOnError"])
continue
toDict[h]=subdict
else:
self.hookmessage(h,"is disabled")
def dumpHooks(self, lst):
for h in lst:
print_(h)
try:
print_(" enabled:",
configuration().getboolean(h, "enabled", default=True))
print_(" module:", configuration().get(h, "module"))
print_(" minRunTime:",
configuration().getfloat(h, "minRunTime", default=0))
print_(" description:",
configuration().get(h, "description", default="None"))
except configparser.NoOptionError:
e = sys.exc_info()[
1] # Needed because python 2.5 does not support 'as e'
self.error("Hook", h, "incompletely defined (", e, ")")
def dumpHooks(self,lst):
for h in lst:
print_(h)
try:
print_(" enabled:",configuration().getboolean(h,
"enabled",
default=True))
print_(" module:",configuration().get(h,
"module"))
print_(" minRunTime:",configuration().getfloat(h,
"minRunTime",
default=0))
print_(" description:",configuration().get(h,
"description",
default="None"))
except configparser.NoOptionError:
e = sys.exc_info()[1] # Needed because python 2.5 does not support 'as e'
self.error("Hook",h,"incompletely defined (",e,")")
def createPlotTimelines(timelines,
custom,
implementation=None,
showWindow=True,
registry=None):
"""Creates a plotting object
@param timelines: The timelines object
@type timelines: TimeLineCollection
@param custom: specifies how the block should look like
@param implementation: the implementation that should be used
"""
if implementation==None:
implementation=configuration().get("Plotting","preferredImplementation")
if implementation not in lookupTable:
error("Requested plotting implementation",implementation,
"not in list of available implementations",list(lookupTable.keys()))
return lookupTable[implementation](timelines,
custom,
showWindow=showWindow,
registry=registry)
def createPlotTimelines(timelines,
custom,
implementation=None,
showWindow=True,
registry=None):
"""Creates a plotting object
@param timelines: The timelines object
@type timelines: TimeLineCollection
@param custom: specifies how the block should look like
@param implementation: the implementation that should be used
"""
if implementation == None:
implementation = configuration().get("Plotting",
"preferredImplementation")
if implementation not in lookupTable:
error("Requested plotting implementation", implementation,
"not in list of available implementations",
list(lookupTable.keys()))
return lookupTable[implementation](timelines,
custom,
showWindow=showWindow,
registry=registry)
def addLocalConfig(self,directory=None):
"""
Adds a local directory (assuming it is found)
"""
if directory!=None:
configuration().addFile(path.join(directory,"LocalConfigPyFoam"),silent=True)
def addOptions(self):
what = OptionGroup(self.parser, "What", "Define what should be shown")
self.parser.add_option_group(what)
what.add_option("--dump",
action="store_true",
dest="dump",
default=False,
help="Dump the information as Python-dictionaries")
what.add_option(
"--disk-usage",
action="store_true",
dest="diskusage",
default=False,
help=
"Show the disk-usage of the case (in MB) - may take a long time")
what.add_option(
"--parallel-info",
action="store_true",
dest="parallel",
default=False,
help=
"Print information about parallel runs (if present): number of processors and processor first and last time. The mtime will be that of the processor-directories"
)
what.add_option("--no-state",
action="store_false",
dest="state",
default=True,
help="Don't read state-files")
what.add_option("--no-hostname",
action="store_false",
dest="hostname",
default=True,
help="Don't look up the hostname in the pickled data")
what.add_option(
"--advanced-state",
action="store_true",
dest="advancedState",
default=False,
help="Additional state information (run started, last output seen)"
)
what.add_option(
"--estimate-end-time",
action="store_true",
dest="estimateEndTime",
default=False,
help=
"Print an estimated end time (calculated from the start time of the run, the current time and the current simulation time)"
)
what.add_option("--start-end-time",
action="store_true",
dest="startEndTime",
default=False,
help="Start and end time from the controlDict")
what.add_option(
"--custom-data",
action="append",
dest="customData",
default=[],
help=
"Specification of additional data that is read from the pickled data-sets. The format is 'name=spec1::spec2::...' where 'name' is the name under which the data ist shown and 'specN' are the dictionary keys under which the data is accessed. If only 'spec1::spec2::..' is given then a name of the form 'CustomN' will be used. Can be specified more than once"
)
what.add_option(
"--solver-name-for-custom-data",
action="store",
dest="solverNameForCustom",
default=None,
help=
"This is used if '--custom-data' is specified as the data will be searched in 'PyFoamRunner.<solver name>.analyzed'. If unset then the utility will try to automatically determine the name of the solver which might be wrong"
)
what.add_option(
"--hg-info",
action="store_true",
dest="hgInfo",
default=False,
help=
"Looks for .hg in the directories and reports mercurial version info (for those who keep track of their cases with mercurial)"
)
how = OptionGroup(self.parser, "How", "How the things should be shown")
self.parser.add_option_group(how)
how.add_option("--sort-by",
type="choice",
action="store",
dest="sort",
default=configuration().get("CommandOptionDefaults",
"sortListCases",
default="name"),
choices=self.sortChoices,
help="Sort the cases by a specific key (Keys: " +
", ".join(self.sortChoices) + ") Default: %default")
how.add_option("--reverse-sort",
action="store_true",
dest="reverse",
default=False,
help="Sort in reverse order")
how.add_option("--relative-times",
action="store_true",
dest="relativeTime",
default=False,
help="Show the timestamps relative to the current time")
behave = OptionGroup(self.parser, "Behaviour", "Additional output etc")
self.parser.add_option_group(behave)
behave.add_option(
"--progress",
action="store_true",
dest="progress",
default=False,
help="Print the directories while they are being processed")
behave.add_option(
"--no-progress-bar",
action="store_false",
dest="progressBar",
default=True,
help="Do not show a progress bar as directories are being processed"
)
behave.add_option(
"--dead-threshold",
action="store",
type="float",
dest="deadThreshold",
default=configuration().get("CommandOptionDefaults",
"deadThresholdListCases"),
help=
"Number of seconds without updates after which the case is assumed to be dead. Default: %default"
)
select = OptionGroup(
self.parser, "Selection",
"Select which cases should be shown. First the select-patterns are applied then the ignore patterns. If no select-patterns are specified then all cases are processed"
)
self.parser.add_option_group(select)
select.add_option("--recursive",
action="store_true",
dest="recursive",
default=False,
help="Recursively search for case directories")
select.add_option(
"--substring-select",
action="append",
dest="substringSelect",
default=[],
help=
"Substrings that should be in the case-name. Can be specified more than once"
)
select.add_option(
"--ignore-substring",
action="append",
dest="substringIgnore",
default=[],
help=
"Substrings that should not be in the case-name. Can be specified more than once"
)
select.add_option(
"--glob-select",
action="append",
dest="globSelect",
default=[],
help=
"Glob-pattern that the case-name should match. Can be specified more than once"
)
select.add_option(
"--no-glob-select",
action="append",
dest="globIgnore",
default=[],
help=
"Glob-pattern that the case-name should not match. Can be specified more than once"
)
def addOptions(self):
what=OptionGroup(self.parser,
"What",
"Define what should be shown")
self.parser.add_option_group(what)
what.add_option("--dump",
action="store_true",
dest="dump",
default=False,
help="Dump the information as Python-dictionaries")
what.add_option("--disk-usage",
action="store_true",
dest="diskusage",
default=False,
help="Show the disk-usage of the case (in MB) - may take a long time")
what.add_option("--parallel-info",
action="store_true",
dest="parallel",
default=False,
help="Print information about parallel runs (if present): number of processors and processor first and last time. The mtime will be that of the processor-directories")
what.add_option("--no-state",
action="store_false",
dest="state",
default=True,
help="Don't read state-files")
what.add_option("--advanced-state",
action="store_true",
dest="advancedState",
default=False,
help="Additional state information (run started, last output seen)")
what.add_option("--estimate-end-time",
action="store_true",
dest="estimateEndTime",
default=False,
help="Print an estimated end time (calculated from the start time of the run, the current time and the current simulation time)")
what.add_option("--start-end-time",
action="store_true",
dest="startEndTime",
default=False,
help="Start and end time from the controlDict")
what.add_option("--custom-data",
action="append",
dest="customData",
default=[],
help="Specification of additional data that is read from the pickled data-sets. The format is 'name=spec1::spec2::...' where 'name' is the name under which the data ist shown and 'specN' are the dictionary keys under which the data is accessed. If only 'spec1::spec2::..' is given then a name of the form 'CustomN' will be used. Can be specified more than once")
what.add_option("--solver-name-for-custom-data",
action="store",
dest="solverNameForCustom",
default=None,
help="This is used if '--custom-data' is specified as the data will be searched in 'PyFoamRunner.<solver name>.analyzed'. If unset then the utility will try to automatically determine the name of the solver which might be wrong")
how=OptionGroup(self.parser,
"How",
"How the things should be shown")
self.parser.add_option_group(how)
how.add_option("--sort-by",
type="choice",
action="store",
dest="sort",
default=configuration().get("CommandOptionDefaults","sortListCases",default="name"),
choices=self.sortChoices,
help="Sort the cases by a specific key (Keys: "+", ".join(self.sortChoices)+") Default: %default")
how.add_option("--reverse-sort",
action="store_true",
dest="reverse",
default=False,
help="Sort in reverse order")
how.add_option("--relative-times",
action="store_true",
dest="relativeTime",
default=False,
help="Show the timestamps relative to the current time")
behave=OptionGroup(self.parser,
"Behaviour",
"Additional output etc")
self.parser.add_option_group(behave)
behave.add_option("--progress",
action="store_true",
dest="progress",
default=False,
help="Print the directories while they are being processed")
def addOptions(self):
what=OptionGroup(self.parser,
"What",
"Define what should be shown")
self.parser.add_option_group(what)
what.add_option("--dump",
action="store_true",
dest="dump",
default=False,
help="Dump the information as Python-dictionaries")
what.add_option("--disk-usage",
action="store_true",
dest="diskusage",
default=False,
help="Show the disk-usage of the case (in MB) - may take a long time")
what.add_option("--parallel-info",
action="store_true",
dest="parallel",
default=False,
help="Print information about parallel runs (if present): number of processors and processor first and last time. The mtime will be that of the processor-directories")
what.add_option("--no-state",
action="store_false",
dest="state",
default=True,
help="Don't read state-files")
what.add_option("--advanced-state",
action="store_true",
dest="advancedState",
default=False,
help="Additional state information (run started, last output seen)")
what.add_option("--estimate-end-time",
action="store_true",
dest="estimateEndTime",
default=False,
help="Print an estimated end time (calculated from the start time of the run, the current time and the current simulation time)")
what.add_option("--start-end-time",
action="store_true",
dest="startEndTime",
default=False,
help="Start and end time from the controlDict")
how=OptionGroup(self.parser,
"How",
"How the things should be shown")
self.parser.add_option_group(how)
how.add_option("--sort-by",
type="choice",
action="store",
dest="sort",
default=configuration().get("CommandOptionDefaults","sortListCases",default="name"),
choices=self.sortChoices,
help="Sort the cases by a specific key (Keys: "+string.join(self.sortChoices,", ")+") Default: %default")
how.add_option("--reverse-sort",
action="store_true",
dest="reverse",
default=False,
help="Sort in reverse order")
how.add_option("--relative-times",
action="store_true",
dest="relativeTime",
default=False,
help="Show the timestamps relative to the current time")
behave=OptionGroup(self.parser,
"Behaviour",
"Additional output etc")
self.parser.add_option_group(behave)
behave.add_option("--progress",
action="store_true",
dest="progress",
default=False,
help="Print the directories while they are being processed")
def getHooksWithPrefix(self,prefix):
lst=[]
for h in configuration().sections():
if h.find(prefix+"_")==0:
lst.append(h)
return lst
def addOptions(self):
what = OptionGroup(self.parser, "What", "Define what should be shown")
self.parser.add_option_group(what)
what.add_option("--dump",
action="store_true",
dest="dump",
default=False,
help="Dump the information as Python-dictionaries")
what.add_option(
"--disk-usage",
action="store_true",
dest="diskusage",
default=False,
help=
"Show the disk-usage of the case (in MB) - may take a long time")
what.add_option(
"--parallel-info",
action="store_true",
dest="parallel",
default=False,
help=
"Print information about parallel runs (if present): number of processors and processor first and last time. The mtime will be that of the processor-directories"
)
what.add_option("--no-state",
action="store_false",
dest="state",
default=True,
help="Don't read state-files")
what.add_option(
"--advanced-state",
action="store_true",
dest="advancedState",
default=False,
help="Additional state information (run started, last output seen)"
)
what.add_option(
"--estimate-end-time",
action="store_true",
dest="estimateEndTime",
default=False,
help=
"Print an estimated end time (calculated from the start time of the run, the current time and the current simulation time)"
)
what.add_option("--start-end-time",
action="store_true",
dest="startEndTime",
default=False,
help="Start and end time from the controlDict")
what.add_option(
"--custom-data",
action="append",
dest="customData",
default=[],
help=
"Specification of additional data that is read from the pickled data-sets. The format is 'name=spec1::spec2::...' where 'name' is the name under which the data ist shown and 'specN' are the dictionary keys under which the data is accessed. If only 'spec1::spec2::..' is given then a name of the form 'CustomN' will be used. Can be specified more than once"
)
what.add_option(
"--solver-name-for-custom-data",
action="store",
dest="solverNameForCustom",
default=None,
help=
"This is used if '--custom-data' is specified as the data will be searched in 'PyFoamRunner.<solver name>.analyzed'. If unset then the utility will try to automatically determine the name of the solver which might be wrong"
)
how = OptionGroup(self.parser, "How", "How the things should be shown")
self.parser.add_option_group(how)
how.add_option("--sort-by",
type="choice",
action="store",
dest="sort",
default=configuration().get("CommandOptionDefaults",
"sortListCases",
default="name"),
choices=self.sortChoices,
help="Sort the cases by a specific key (Keys: " +
", ".join(self.sortChoices) + ") Default: %default")
how.add_option("--reverse-sort",
action="store_true",
dest="reverse",
default=False,
help="Sort in reverse order")
how.add_option("--relative-times",
action="store_true",
dest="relativeTime",
default=False,
help="Show the timestamps relative to the current time")
behave = OptionGroup(self.parser, "Behaviour", "Additional output etc")
self.parser.add_option_group(behave)
behave.add_option(
"--progress",
action="store_true",
dest="progress",
default=False,
help="Print the directories while they are being processed")
def prepare(self,sol,
cName=None,
overrideParameters=None,
numberOfProcessors=None):
"""Do the actual preparing
@param numberOfProcessors: If set this overrides the value set in the
command line"""
if cName==None:
cName=sol.name
if self.opts.onlyVariables:
self.opts.verbose=True
vals={}
vals,self.metaData=self.getDefaultValues(cName)
vals.update(self.addDictValues("System",
"Automatically defined values",
{
"casePath" : '"'+path.abspath(cName)+'"',
"caseName" : '"'+path.basename(path.abspath(cName))+'"',
"foamVersion" : foamVersion(),
"foamFork" : foamFork(),
"numberOfProcessors" : numberOfProcessors if numberOfProcessors!=None else self.opts.numberOfProcessors
}))
if len(self.opts.extensionAddition)>0:
vals.update(self.addDictValues("ExtensionAdditions",
"Additional extensions to be processed",
dict((e,True) for e in self.opts.extensionAddition)))
valsWithDefaults=set(vals.keys())
self.info("Looking for template values",cName)
for f in self.opts.valuesDicts:
self.info("Reading values from",f)
vals.update(ParsedParameterFile(f,
noHeader=True,
doMacroExpansion=True).getValueDict())
setValues={}
for v in self.opts.values:
self.info("Updating values",v)
vals.update(eval(v))
setValues.update(eval(v))
if overrideParameters:
vals.update(overrideParameters)
unknownValues=set(vals.keys())-valsWithDefaults
if len(unknownValues)>0:
self.warning("Values for which no default was specified: "+
", ".join(unknownValues))
if self.opts.verbose and len(vals)>0:
print_("\nUsed values\n")
nameLen=max(len("Name"),
max(*[len(k) for k in vals.keys()]))
format="%%%ds - %%s" % nameLen
print_(format % ("Name","Value"))
print_("-"*40)
for k,v in sorted(iteritems(vals)):
print_(format % (k,v))
print_("")
else:
self.info("\nNo values specified\n")
self.checkCorrectOptions(vals)
derivedScript=path.join(cName,self.opts.derivedParametersScript)
if path.exists(derivedScript):
self.info("Deriving variables in script",derivedScript)
scriptText=open(derivedScript).read()
glob={}
oldVals=vals.copy()
exec_(scriptText,glob,vals)
added=[]
changed=[]
for k,v in iteritems(vals):
if k not in oldVals:
added.append(k)
elif vals[k]!=oldVals[k]:
changed.append(k)
if len(changed)>0 and (not self.opts.allowDerivedChanges and not configuration().getboolean("PrepareCase","AllowDerivedChanges")):
self.error(self.opts.derivedParametersScript,
"changed values of"," ".join(changed),
"\nTo allow this set --allow-derived-changes or the configuration item 'AllowDerivedChanges'")
if len(added)>0:
self.info("Added values:"," ".join(added))
if len(changed)>0:
self.info("Changed values:"," ".join(changed))
if len(added)==0 and len(changed)==0:
self.info("Nothing added or changed")
else:
self.info("No script",derivedScript,"for derived values")
if self.opts.onlyVariables:
return
if self.opts.doClear:
self.info("Clearing",cName)
sol.clear(processor=True,
pyfoam=True,
vtk=True,
removeAnalyzed=True,
keepParallel=False,
clearHistory=False,
clearParameters=True,
additional=["postProcessing"])
if self.opts.writeParameters:
fName=path.join(cName,self.parameterOutFile)
self.info("Writing parameters to",fName)
with WriteParameterFile(fName,noHeader=True) as w:
w.content.update(vals,toString=True)
w["foamVersion"]=vals["foamVersion"]
w.writeFile()
if self.opts.writeReport:
fName=path.join(cName,self.parameterOutFile+".rst")
self.info("Writing report to",fName)
with open(fName,"w") as w:
helper=RestructuredTextHelper(defaultHeading=1)
w.write(".. title:: "+self.__strip(vals["caseName"])+"\n")
w.write(".. sectnum::\n")
w.write(".. header:: "+self.__strip(vals["caseName"])+"\n")
w.write(".. header:: "+time.asctime()+"\n")
w.write(".. footer:: ###Page### / ###Total###\n\n")
w.write("Parameters set in case directory "+
helper.literal(self.__strip(vals["casePath"]))+" at "+
helper.emphasis(time.asctime())+"\n\n")
w.write(".. contents::\n\n")
if len(self.opts.valuesDicts):
w.write(helper.heading("Parameter files"))
w.write("Parameters read from files\n\n")
w.write(helper.enumerateList([helper.literal(f) for f in self.opts.valuesDicts]))
w.write("\n")
if len(setValues)>0:
w.write(helper.heading("Overwritten parameters"))
w.write("These parameters were set from the command line\n\n")
w.write(helper.definitionList(setValues))
w.write("\n")
w.write(helper.heading("Parameters with defaults"))
w.write(self.makeReport(vals))
if len(unknownValues)>0:
w.write(helper.heading("Unspecified parameters"))
w.write("If these parameters are actually used then specify them in "+
helper.literal(self.defaultParameterFile)+"\n\n")
tab=helper.table(True)
for u in unknownValues:
tab.addRow(u)
tab.addItem("Value",vals[u])
w.write(str(tab))
self.addToCaseLog(cName)
for over in self.opts.overloadDirs:
self.info("Overloading files from",over)
self.overloadDir(sol.name,over)
zeroOrig=path.join(sol.name,"0.org")
hasOrig=path.exists(zeroOrig)
cleanZero=True
if not hasOrig:
self.info("Not going to clean '0'")
self.opts.cleanDirectories.remove("0")
cleanZero=False
if self.opts.doCopy:
if hasOrig:
self.info("Found 0.org. Clearing 0")
zeroDir=path.join(sol.name,"0")
if path.exists(zeroDir):
rmtree(zeroDir)
else:
self.info("No 0-directory")
self.info("")
else:
cleanZero=False
if self.opts.doTemplates:
self.searchAndReplaceTemplates(sol.name,
vals,
self.opts.templateExt)
self.info("")
backupZeroDir=None
if self.opts.doMeshCreate:
if self.opts.meshCreateScript:
scriptName=path.join(sol.name,self.opts.meshCreateScript)
if not path.exists(scriptName):
self.error("Script",scriptName,"does not exist")
elif path.exists(path.join(sol.name,self.defaultMeshCreate)):
scriptName=path.join(sol.name,self.defaultMeshCreate)
else:
scriptName=None
if scriptName:
self.info("Executing",scriptName,"for mesh creation")
if self.opts.verbose:
echo="Mesh: "
else:
echo=None
result="".join(execute([scriptName],workdir=sol.name,echo=echo))
open(scriptName+".log","w").write(result)
else:
self.info("No script for mesh creation found. Looking for 'blockMeshDict'")
if sol.blockMesh()!="":
self.info(sol.blockMesh(),"found. Executing 'blockMesh'")
bm=BasicRunner(argv=["blockMesh","-case",sol.name])
bm.start()
if not bm.runOK():
self.error("Problem with blockMesh")
for r in sol.regions():
self.info("Checking region",r)
s=SolutionDirectory(sol.name,region=r,
archive=None,paraviewLink=False)
if s.blockMesh()!="":
self.info(s.blockMesh(),"found. Executing 'blockMesh'")
bm=BasicRunner(argv=["blockMesh","-case",sol.name,
"-region",r])
bm.start()
if not bm.runOK():
self.error("Problem with blockMesh")
self.info("")
if cleanZero and path.exists(zeroDir):
self.warning("Mesh creation recreated 0-directory")
if self.opts.keepZeroDirectoryFromMesh:
backupZeroDir=zeroDir+".bakByPyFoam"
self.info("Backing up",zeroDir,"to",backupZeroDir)
move(zeroDir,backupZeroDir)
else:
self.info("Data in",zeroDir,"will be removed")
if self.opts.doCopy:
self.copyOriginals(sol.name)
self.info("")
if backupZeroDir:
self.info("Copying backups from",backupZeroDir,"to",zeroDir)
self.overloadDir(zeroDir,backupZeroDir)
self.info("Removing backup",backupZeroDir)
rmtree(backupZeroDir)
if self.opts.doPostTemplates:
self.searchAndReplaceTemplates(sol.name,
vals,
self.opts.postTemplateExt)
self.info("")
if self.opts.doCaseSetup:
if self.opts.caseSetupScript:
scriptName=path.join(sol.name,self.opts.caseSetupScript)
if not path.exists(scriptName):
self.error("Script",scriptName,"does not exist")
elif path.exists(path.join(sol.name,self.defaultCaseSetup)):
scriptName=path.join(sol.name,self.defaultCaseSetup)
else:
scriptName=None
if scriptName:
self.info("Executing",scriptName,"for case setup")
if self.opts.verbose:
echo="Case:"
else:
echo=None
result="".join(execute([scriptName],workdir=sol.name,echo=echo))
open(scriptName+".log","w").write(result)
else:
self.info("No script for case-setup found. Nothing done")
self.info("")
if self.opts.doFinalTemplates:
self.searchAndReplaceTemplates(sol.name,
vals,
self.opts.finalTemplateExt)
if self.opts.doTemplateClean:
self.info("Clearing templates")
for d in self.opts.cleanDirectories:
for e in [self.opts.templateExt,
self.opts.postTemplateExt,
self.opts.finalTemplateExt]:
self.cleanExtension(path.join(sol.name,d),e)
self.info("")
self.info("Case setup finished")
def getHooksWithPrefix(self, prefix):
lst = []
for h in configuration().sections():
if h.find(prefix + "_") == 0:
lst.append(h)
return lst
def __init__(self,
args=None,
description=None,
epilog=None,
examples=None,
usage=None,
interspersed=False,
nr=None,
changeVersion=True,
exactNr=True,
subcommands=None,
inputApp=None,
localConfigurationFile=None,
findLocalConfigurationFile=None,
**kwArgs):
"""
:param description: description of the command
:param epilog: text to be printed after the options-help
:param examples: usage examples to be printed after the epilog
:param usage: Usage
:param interspersed: Is the command line allowed to be interspersed (options after the arguments)
:param args: Command line arguments when using the Application as a 'class' from a script
:param nr: Number of required arguments
:param changeVersion: May this application change the version of OF used?
:param exactNr: Must not have more than the required number of arguments
:param subcommands: parse and use subcommands from the command line. Either True or a list with subcommands
:param inputApp: Application with input data. Used to allow a 'pipe-like' behaviour if the class is used from a Script
:param localConfigurationFile: Use this file (or list of files) as a local configuration
:param findLocalConfigurationFile: Method to find a configuration file BEFORE the actual parameters are parsed
"""
global _LocalConfigurationFile
if _LocalConfigurationFile is not None:
configuration().addFile(_LocalConfigurationFile)
if isinstance(localConfigurationFile, string_types):
configuration().addFile(localConfigurationFile)
elif localConfigurationFile is not None:
for c in localConfigurationFile:
configuration().addFile(c)
if subcommands:
self.subs = True
if interspersed:
self.error(
"Subcommand parser does not work with 'interspersed'")
if subcommands == True:
subcommands = []
self.parser = SubcommandFoamOptionParser(args=args,
description=description,
epilog=epilog,
examples=examples,
usage=usage,
subcommands=subcommands)
nr = None
exactNr = False
else:
self.subs = False
self.parser = FoamOptionParser(args=args,
description=description,
epilog=epilog,
examples=examples,
usage=usage,
interspersed=interspersed)
self.calledName = sys.argv[0]
self.calledAsClass = (args != None)
if self.calledAsClass:
self.calledName = self.__class__.__name__ + " used by " + sys.argv[
0]
self.parser.prog = self.calledName
elif not _LocalConfigurationFile and findLocalConfigurationFile:
if args:
usedArgs = args
else:
usedArgs = sys.argv[1:]
_LocalConfigurationFile = findLocalConfigurationFile(usedArgs)
if _LocalConfigurationFile and not path.exists(
_LocalConfigurationFile):
# Fix functions that do not check for the existence
_LocalConfigurationFile = None
if _LocalConfigurationFile:
configuration().addFile(_LocalConfigurationFile)
self.generalOpts = None
self.__appData = self.iDict()
if inputApp:
self.__appData["inputData"] = inputApp.getData()
grp = OptionGroup(self.parser, "Default",
"Options common to all PyFoam-applications")
if changeVersion:
# the options are evaluated in Basics.FoamOptionParser
grp.add_option(
"--foamVersion",
dest="foamVersion",
default=None,
help=
"Change the OpenFOAM-version that is to be used. To get a list of know Foam-versions use the pyFoamVersion.py-utility"
)
if "WM_PROJECT_VERSION" in environ:
grp.add_option("--currentFoamVersion",
dest="foamVersion",
const=environ["WM_PROJECT_VERSION"],
default=None,
action="store_const",
help="Use the current OpenFOAM-version " +
environ["WM_PROJECT_VERSION"])
grp.add_option(
"--force-32bit",
dest="force32",
default=False,
action="store_true",
help=
"Forces the usage of a 32-bit-version if that version exists as 32 and 64 bit. Only used when --foamVersion is used"
)
grp.add_option(
"--force-64bit",
dest="force64",
default=False,
action="store_true",
help=
"Forces the usage of a 64-bit-version if that version exists as 32 and 64 bit. Only used when --foamVersion is used"
)
grp.add_option(
"--force-debug",
dest="compileOption",
const="Debug",
default=None,
action="store_const",
help=
"Forces the value Debug for the WM_COMPILE_OPTION. Only used when --foamVersion is used"
)
grp.add_option(
"--force-opt",
dest="compileOption",
const="Opt",
default=None,
action="store_const",
help=
"Forces the value Opt for the WM_COMPILE_OPTION. Only used when --foamVersion is used"
)
grp.add_option(
"--force-system-compiler",
dest="foamCompiler",
const="system",
default=None,
action="store_const",
help=
"Force using a 'system' compiler (compiler installed in the system)"
)
grp.add_option(
"--force-openfoam-compiler",
dest="foamCompiler",
const="OpenFOAM",
default=None,
action="store_const",
help=
"Force using a 'OpenFOAM' compiler (compiler installed in ThirdParty)"
)
grp.add_option(
"--force-compiler",
dest="wmCompiler",
default=None,
action="store",
help="Overwrite value for WM_COMPILER (for instance Gcc47 ...)"
)
grp.add_option(
"--psyco-accelerated",
dest="psyco",
default=False,
action="store_true",
help=
"Accelerate the script using the psyco-library (EXPERIMENTAL and requires a separatly installed psyco)"
)
grp.add_option(
"--profile-python",
dest="profilePython",
default=False,
action="store_true",
help=
"Profile the python-script (not the OpenFOAM-program) - mostly of use for developers"
)
grp.add_option(
"--profile-cpython",
dest="profileCPython",
default=False,
action="store_true",
help=
"Profile the python-script (not the OpenFOAM-program) using the better cProfile library - mostly of use for developers"
)
grp.add_option(
"--profile-hotshot",
dest="profileHotshot",
default=False,
action="store_true",
help=
"Profile the python-script using the hotshot-library (not the OpenFOAM-program) - mostly of use for developers - DEPRECATED as this library will by removed from standard python and is no longer supported"
)
grp.add_option(
"--profile-line-profiler",
dest="profileLineProfiler",
default=False,
action="store_true",
help=
"Profile the python-script using the line_profiler-library (not the OpenFOAM-program) - mostly of use for developers - EXPERIMENTAL"
)
dbg = OptionGroup(
self.parser, "Debugging",
"Options mainly used for debugging PyFoam-Utilities")
dbg.add_option(
"--location-of-local-config",
dest="locationOfLocalConfig",
default=False,
action="store_true",
help=
"Prints the location of the found LocalConfigPyFoam-file that is used (if any)"
)
dbg.add_option(
"--traceback-on-error",
dest="traceback",
default=False,
action="store_true",
help=
"Prints a traceback when an error is encountered (for debugging)")
dbg.add_option(
"--interactive-debugger",
dest="interactiveDebug",
default=False,
action="store_true",
help=
"In case of an exception start the interactive debugger PDB. Also implies --traceback-on-error"
)
dbg.add_option(
"--catch-USR1-signal",
dest="catchUSR1Signal",
default=False,
action="store_true",
help=
"If the USR1-signal is sent to the application with 'kill -USR1 <pid>' the application ens and prints a traceback. If interactive debugging is enabled then the debugger is entered. Use to investigate hangups"
)
dbg.add_option("--also-catch-TERM-signal",
dest="alsoCatchTERMsignal",
default=False,
action="store_true",
help="In addition to USR1 catch the regular TERM-kill")
dbg.add_option(
"--keyboard-interrupt-trace",
dest="keyboardInterrupTrace",
default=False,
action="store_true",
help=
"Make the application behave like with --catch-USR1-signal if <Ctrl>-C is pressed"
)
dbg.add_option(
"--syntax-error-debugger",
dest="syntaxErrorDebugger",
default=False,
action="store_true",
help=
"Only makes sense with --interactive-debugger: Do interactive debugging even when a syntax error was encountered"
)
dbg.add_option(
"--i-am-a-developer",
dest="developerMode",
default=False,
action="store_true",
help=
"Switch on all of the above options. Usually this makes only sense if you're developing PyFoam'"
)
dbg.add_option(
"--interactive-after-execution",
dest="interacticeAfterExecution",
default=False,
action="store_true",
help=
"Instead of ending execution drop to an interactive shell (which is IPython if possible)"
)
grp.add_option(
"--dump-application-data",
dest="dumpAppData",
default=False,
action="store_true",
help=
"Print the dictionary with the generated application data after running"
)
grp.add_option("--pickle-application-data",
dest="pickleApplicationData",
default=None,
action="store",
type="string",
help="""\
Write a pickled version of the application data to a file. If the
filename given is 'stdout' then the pickled data is written to
stdout. The usual standard output is then captured and added to the
application data as an entry 'stdout' (same for 'stderr'). Be careful
with these option for commands that generate a lot of output""")
self.parser.add_option_group(grp)
self.parser.add_option_group(dbg)
self.addOptions()
self.parser.parse(nr=nr, exactNr=exactNr)
ensureDynamicLibraries()
if len(kwArgs) > 0:
self.parser.processKeywordArguments(kwArgs)
self.opts = self.parser.getOptions()
if self.subs:
self.cmdname = self.parser.cmdname
if self.opts.locationOfLocalConfig:
if _LocalConfigurationFile:
print_("Local configuration found at", _LocalConfigurationFile)
else:
print_("No LocalConfigPyFoam-file found")
if "WM_PROJECT_VERSION" not in environ:
warning(
"$WM_PROJECT_VERSION unset. PyFoam will not be able to determine the OpenFOAM-version and behave strangely"
)
if self.opts.developerMode:
self.opts.syntaxErrorDebugger = True
self.opts.keyboardInterrupTrace = True
self.opts.alsoCatchTERMsignal = True
self.opts.catchUSR1Signal = True
self.opts.interactiveDebug = True
self.opts.traceback = True
if self.opts.interactiveDebug:
sys.excepthook = lambda a1, a2, a3: pyFoamExceptionHook(
a1, a2, a3, debugOnSyntaxError=self.opts.syntaxErrorDebugger)
self.opts.traceback = True
if self.opts.catchUSR1Signal:
import signal
signal.signal(signal.SIGUSR1, pyFoamSIG1HandlerPrintStack)
if self.opts.alsoCatchTERMsignal:
signal.signal(signal.SIGTERM, pyFoamSIG1HandlerPrintStack)
self.opts.traceback = True
if self.opts.keyboardInterrupTrace:
import signal
signal.signal(signal.SIGINT, pyFoamSIG1HandlerPrintStack)
self.opts.traceback = True
if self.opts.psyco:
try:
import psyco
psyco.full()
except ImportError:
warning("No psyco installed. Continuing without acceleration")
profOptions = sum([
self.opts.profilePython, self.opts.profileCPython,
self.opts.profileHotshot, self.opts.profileLineProfiler
])
if profOptions > 0:
if profOptions > 1:
self.error(
"Only one profiling option can be specified at a time")
print_("Running profiled")
fnAdd = ""
if self.opts.profilePython:
import profile
elif self.opts.profileCPython:
import cProfile as profile
elif self.opts.profileLineProfiler:
import line_profiler
profile = line_profiler.LineProfiler(self.run)
import PyFoam.RunDictionary.SolutionDirectory
profile.add_module(PyFoam.RunDictionary.SolutionDirectory)
fnAdd = ".lineProfiler"
else:
import hotshot
profileData = path.basename(sys.argv[0]) + fnAdd + ".profile"
if self.opts.profilePython or self.opts.profileCPython:
profile.runctx('self.run()', None, {'self': self}, profileData)
print_("Reading python profile")
import pstats
stats = pstats.Stats(profileData)
elif self.opts.profileLineProfiler:
import inspect
nr = profile.add_module(inspect.getmodule(self))
self.warning("Adding", nr, "functions for line-profiling")
profile.runctx('self.run()', None, {'self': self})
profile.dump_stats(profileData)
profile.print_stats(open(profileData + ".printed", "w"))
stats = None
else:
profileData += ".hotshot"
prof = hotshot.Profile(profileData)
prof.runctx('self.run()', {}, {'self': self})
print_("Writing and reading hotshot profile")
prof.close()
import hotshot.stats
stats = hotshot.stats.load(profileData)
if stats:
stats.strip_dirs()
stats.sort_stats('time', 'calls')
stats.print_stats(20)
self.parser.restoreEnvironment()
else:
try:
if self.opts.pickleApplicationData == "stdout":
# Redirect output to memory
from PyFoam.ThirdParty.six.moves import StringIO
oldStdout = sys.stdout
oldStderr = sys.stderr
sys.stdout = StringIO()
sys.stderr = StringIO()
result = self.run()
# do this at the earliest possible moment
self.parser.restoreEnvironment()
if self.opts.pickleApplicationData == "stdout":
# restore stdout
self.__appData["stdout"] = sys.stdout.getvalue()
self.__appData["stderr"] = sys.stderr.getvalue()
sys.stdout = oldStdout
sys.stderr = oldStderr
if self.opts.pickleApplicationData:
from PyFoam.ThirdParty.six.moves import cPickle as pickle
if self.opts.pickleApplicationData == "stdout":
pick = pickle.Pickler(sys.stdout)
else:
pick = pickle.Pickler(
open(self.opts.pickleApplicationData, 'wb'))
pick.dump(self.__appData)
del pick
if self.opts.dumpAppData:
import pprint
print_("Application data:")
printer = pprint.PrettyPrinter()
printer.pprint(self.__appData)
if self.opts.interacticeAfterExecution:
print_("\nDropping to interactive shell ... ", end="")
ns = {}
ns.update(locals())
ns.update(globals())
try:
import IPython
print_("found IPython ...", end="")
if "embed" in dir(IPython):
print_("up-to-date IPython\n")
IPython.embed(user_ns=ns)
else:
print_("old-school IPython\n")
IPython.Shell.IPythonShellEmbed(argv="",
user_ns=ns)()
except ImportError:
print_("no IPython -> regular shell\n")
from code import InteractiveConsole
c = InteractiveConsole(ns)
c.interact()
print_("\nEnding interactive shell\n")
return result
except PyFoamException:
e = sys.exc_info()[1]
if self.opts.traceback or self.calledAsClass:
raise
else:
self.errorPrint(str(e))
def prepare(self,
sol,
cName=None,
overrideParameters=None,
numberOfProcessors=None):
"""Do the actual preparing
:param numberOfProcessors: If set this overrides the value set in the
command line"""
if cName == None:
cName = sol.name
if self.opts.onlyVariables:
self.opts.verbose = True
vals = {}
vals, self.metaData = self.getDefaultValues(cName)
vals.update(
self.addDictValues(
"System", "Automatically defined values", {
"casePath":
'"' + path.abspath(cName) + '"',
"caseName":
'"' + path.basename(path.abspath(cName)) + '"',
"foamVersion":
foamVersion(),
"foamFork":
foamFork(),
"numberOfProcessors":
numberOfProcessors if numberOfProcessors != None else
self.opts.numberOfProcessors
}))
if len(self.opts.extensionAddition) > 0:
vals.update(
self.addDictValues(
"ExtensionAdditions",
"Additional extensions to be processed",
dict((e, True) for e in self.opts.extensionAddition)))
valsWithDefaults = set(vals.keys())
self.info("Looking for template values", cName)
for f in self.opts.valuesDicts:
self.info("Reading values from", f)
vals.update(
ParsedParameterFile(f, noHeader=True,
doMacroExpansion=True).getValueDict())
setValues = {}
for v in self.opts.values:
self.info("Updating values", v)
vals.update(eval(v))
setValues.update(eval(v))
if overrideParameters:
vals.update(overrideParameters)
unknownValues = set(vals.keys()) - valsWithDefaults
if len(unknownValues) > 0:
self.warning("Values for which no default was specified: " +
", ".join(unknownValues))
if self.opts.verbose and len(vals) > 0:
print_("\nUsed values\n")
nameLen = max(len("Name"), max(*[len(k) for k in vals.keys()]))
format = "%%%ds - %%s" % nameLen
print_(format % ("Name", "Value"))
print_("-" * 40)
for k, v in sorted(iteritems(vals)):
print_(format % (k, v))
print_("")
else:
self.info("\nNo values specified\n")
self.checkCorrectOptions(vals)
derivedScript = path.join(cName, self.opts.derivedParametersScript)
derivedAdded = None
derivedChanged = None
if path.exists(derivedScript):
self.info("Deriving variables in script", derivedScript)
scriptText = open(derivedScript).read()
glob = {}
oldVals = vals.copy()
exec_(scriptText, glob, vals)
derivedAdded = []
derivedChanged = []
for k, v in iteritems(vals):
if k not in oldVals:
derivedAdded.append(k)
elif vals[k] != oldVals[k]:
derivedChanged.append(k)
if len(derivedChanged) > 0 and (
not self.opts.allowDerivedChanges
and not configuration().getboolean("PrepareCase",
"AllowDerivedChanges")):
self.error(
self.opts.derivedParametersScript, "changed values of",
" ".join(derivedChanged),
"\nTo allow this set --allow-derived-changes or the configuration item 'AllowDerivedChanges'"
)
if len(derivedAdded) > 0:
self.info("Added values:", " ".join(derivedAdded))
if len(derivedChanged) > 0:
self.info("Changed values:", " ".join(derivedChanged))
if len(derivedAdded) == 0 and len(derivedChanged) == 0:
self.info("Nothing added or changed")
else:
self.info("No script", derivedScript, "for derived values")
if self.opts.onlyVariables:
return
self.__writeToStateFile(sol, "Starting")
if self.opts.doClear:
self.info("Clearing", cName)
self.__writeToStateFile(sol, "Clearing")
sol.clear(processor=True,
pyfoam=True,
vtk=True,
removeAnalyzed=True,
keepParallel=False,
clearHistory=False,
clearParameters=True,
additional=["postProcessing"])
self.__writeToStateFile(sol, "Done clearing")
if self.opts.writeParameters:
fName = path.join(cName, self.parameterOutFile)
self.info("Writing parameters to", fName)
with WriteParameterFile(fName, noHeader=True) as w:
w.content.update(vals, toString=True)
w["foamVersion"] = vals["foamVersion"]
w.writeFile()
if self.opts.writeReport:
fName = path.join(cName, self.parameterOutFile + ".rst")
self.info("Writing report to", fName)
with open(fName, "w") as w:
helper = RestructuredTextHelper(defaultHeading=1)
w.write(".. title:: " + self.__strip(vals["caseName"]) + "\n")
w.write(".. sectnum::\n")
w.write(".. header:: " + self.__strip(vals["caseName"]) + "\n")
w.write(".. header:: " + time.asctime() + "\n")
w.write(".. footer:: ###Page### / ###Total###\n\n")
w.write("Parameters set in case directory " +
helper.literal(self.__strip(vals["casePath"])) +
" at " + helper.emphasis(time.asctime()) + "\n\n")
w.write(".. contents::\n\n")
if len(self.opts.valuesDicts):
w.write(helper.heading("Parameter files"))
w.write("Parameters read from files\n\n")
w.write(
helper.enumerateList([
helper.literal(f) for f in self.opts.valuesDicts
]))
w.write("\n")
if len(setValues) > 0:
w.write(helper.heading("Overwritten parameters"))
w.write(
"These parameters were set from the command line\n\n")
w.write(helper.definitionList(setValues))
w.write("\n")
w.write(helper.heading("Parameters with defaults"))
w.write(self.makeReport(vals))
if len(unknownValues) > 0:
w.write(helper.heading("Unspecified parameters"))
w.write(
"If these parameters are actually used then specify them in "
+ helper.literal(self.defaultParameterFile) + "\n\n")
tab = helper.table(True)
for u in unknownValues:
tab.addRow(u)
tab.addItem("Value", vals[u])
w.write(str(tab))
if not derivedAdded is None:
w.write(helper.heading("Derived Variables"))
w.write("Script with derived Parameters" +
helper.literal(derivedScript) + "\n\n")
if len(derivedAdded) > 0:
w.write("These values were added:\n")
tab = helper.table(True)
for a in derivedAdded:
tab.addRow(a)
tab.addItem("Value", str(vals[a]))
w.write(str(tab))
if len(derivedChanged) > 0:
w.write("These values were changed:\n")
tab = helper.table(True)
for a in derivedChanged:
tab.addRow(a)
tab.addItem("Value", str(vals[a]))
tab.addItem("Old", str(oldVals[a]))
w.write(str(tab))
w.write("The code of the script:\n")
w.write(helper.code(scriptText))
self.addToCaseLog(cName)
for over in self.opts.overloadDirs:
self.info("Overloading files from", over)
self.__writeToStateFile(sol, "Overloading")
self.overloadDir(sol.name, over)
self.__writeToStateFile(sol, "Initial")
zeroOrig = path.join(sol.name, "0.org")
hasOrig = path.exists(zeroOrig)
cleanZero = True
if not hasOrig:
self.info("Not going to clean '0'")
self.opts.cleanDirectories.remove("0")
cleanZero = False
if self.opts.doCopy:
if hasOrig:
self.info("Found 0.org. Clearing 0")
zeroDir = path.join(sol.name, "0")
if path.exists(zeroDir):
rmtree(zeroDir)
else:
self.info("No 0-directory")
self.info("")
else:
cleanZero = False
if self.opts.doTemplates:
self.__writeToStateFile(sol, "Templates")
self.searchAndReplaceTemplates(
sol.name,
vals,
self.opts.templateExt,
ignoreDirectories=self.opts.ignoreDirectories)
self.info("")
backupZeroDir = None
if self.opts.doMeshCreate:
self.__writeToStateFile(sol, "Meshing")
if self.opts.meshCreateScript:
scriptName = path.join(sol.name, self.opts.meshCreateScript)
if not path.exists(scriptName):
self.error("Script", scriptName, "does not exist")
elif path.exists(path.join(sol.name, self.defaultMeshCreate)):
scriptName = path.join(sol.name, self.defaultMeshCreate)
else:
scriptName = None
if scriptName:
self.info("Executing", scriptName, "for mesh creation")
if self.opts.verbose:
echo = "Mesh: "
else:
echo = None
self.executeScript(scriptName, workdir=sol.name, echo=echo)
else:
self.info(
"No script for mesh creation found. Looking for 'blockMeshDict'"
)
if sol.blockMesh() != "":
self.info(sol.blockMesh(), "found. Executing 'blockMesh'")
bm = BasicRunner(argv=["blockMesh", "-case", sol.name])
bm.start()
if not bm.runOK():
self.error("Problem with blockMesh")
for r in sol.regions():
self.info("Checking region", r)
s = SolutionDirectory(sol.name,
region=r,
archive=None,
paraviewLink=False)
if s.blockMesh() != "":
self.info(s.blockMesh(),
"found. Executing 'blockMesh'")
bm = BasicRunner(argv=[
"blockMesh", "-case", sol.name, "-region", r
])
bm.start()
if not bm.runOK():
self.error("Problem with blockMesh")
self.info("")
if cleanZero and path.exists(zeroDir):
self.warning("Mesh creation recreated 0-directory")
if self.opts.keepZeroDirectoryFromMesh:
backupZeroDir = zeroDir + ".bakByPyFoam"
self.info("Backing up", zeroDir, "to", backupZeroDir)
move(zeroDir, backupZeroDir)
else:
self.info("Data in", zeroDir, "will be removed")
self.__writeToStateFile(sol, "Done Meshing")
if self.opts.doCopy:
self.__writeToStateFile(sol, "Copying")
self.copyOriginals(sol.name)
self.info("")
if backupZeroDir:
self.info("Copying backups from", backupZeroDir, "to", zeroDir)
self.overloadDir(zeroDir, backupZeroDir)
self.info("Removing backup", backupZeroDir)
rmtree(backupZeroDir)
if self.opts.doPostTemplates:
self.__writeToStateFile(sol, "Post-templates")
self.searchAndReplaceTemplates(
sol.name,
vals,
self.opts.postTemplateExt,
ignoreDirectories=self.opts.ignoreDirectories)
self.info("")
if self.opts.doCaseSetup:
self.__writeToStateFile(sol, "Case setup")
if self.opts.caseSetupScript:
scriptName = path.join(sol.name, self.opts.caseSetupScript)
if not path.exists(scriptName):
self.error("Script", scriptName, "does not exist")
elif path.exists(path.join(sol.name, self.defaultCaseSetup)):
scriptName = path.join(sol.name, self.defaultCaseSetup)
else:
scriptName = None
if scriptName:
self.info("Executing", scriptName, "for case setup")
if self.opts.verbose:
echo = "Case:"
else:
echo = None
self.executeScript(scriptName, workdir=sol.name, echo=echo)
elif path.exists(path.join(sol.name, "system", "setFieldsDict")):
self.info(
"So setup script found. But 'setFieldsDict'. Executing setFields"
)
sf = BasicRunner(argv=["setFields", "-case", sol.name])
sf.start()
if not sf.runOK():
self.error("Problem with setFields")
else:
self.info("No script for case-setup found. Nothing done")
self.info("")
self.__writeToStateFile(sol, "Done case setup")
if self.opts.doFinalTemplates:
self.__writeToStateFile(sol, "Final templates")
self.searchAndReplaceTemplates(
sol.name,
vals,
self.opts.finalTemplateExt,
ignoreDirectories=self.opts.ignoreDirectories)
if self.opts.doTemplateClean:
self.info("Clearing templates")
for d in self.opts.cleanDirectories:
for e in [
self.opts.templateExt, self.opts.postTemplateExt,
self.opts.finalTemplateExt
]:
self.cleanExtension(path.join(sol.name, d), e)
self.info("")
self.info("Case setup finished")
self.__writeToStateFile(sol, "Finished OK")
def __init__(self,
args=None,
exactNr=True,
interspersed=True,
usage="%prog <caseDirectory>",
examples=None,
nr=1,
description=None,
**kwargs):
self.defaultMeshCreate = configuration().get("PrepareCase",
"MeshCreateScript")
self.defaultCaseSetup = configuration().get("PrepareCase",
"CaseSetupScript")
self.defaultParameterFile = configuration().get(
"PrepareCase", "DefaultParameterFile")
self.defaultIgnoreDirecotries = configuration().getList(
"PrepareCase", "IgnoreDirectories")
description2 = """\
Prepares a case for running. This is intended to be the replacement for
boiler-plate scripts. The steps done are
1. Clear old data from the case (including processor directories)
2. if a folder 0.org is present remove the 0 folder too
3. go through all folders and for every found file with the extension .template
do template expansion using the pyratemp-engine (automatically create variables
casePath and caseName)
4. create a mesh (either by using a script or if a blockMeshDict is present by
running blockMesh. If none of these is present assume that there is a valid mesh
present)
5. copy every foo.org that is found to to foo (recursively if directory)
6. do template-expansion for every file with the extension .postTemplate
7. execute another preparation script (caseSetup.sh). If no such script is found
but a setFieldsDict in system then setFields is executed
8. do final template-expansion for every file with the extension .finalTemplate
The used parameters are written to a file 'PyFoamPrepareCaseParameters' and are used by other utilities
"""
examples2 = """\
%prog . --paramter-file=parameters.base
Prepare the current case with the parameters list in parameters.base
%prog . --paramter-file=parameters.base --values-string="{'visco':1e-3}"
Changes the value of the parameter visco
%prog . --no-mesh-create
Skip the mesh creation phase
"""
PyFoamApplication.__init__(
self,
args=args,
description=description if description else description2,
usage=usage,
examples=examples if examples else examples2,
interspersed=interspersed,
nr=nr,
exactNr=exactNr,
findLocalConfigurationFile=self.localConfigInArgs,
**kwargs)
def __init__(self,
args=None,
description=None,
epilog=None,
examples=None,
usage=None,
interspersed=False,
nr=None,
changeVersion=True,
exactNr=True,
subcommands=None,
inputApp=None,
localConfigurationFile=None,
findLocalConfigurationFile=None,
**kwArgs):
"""
@param description: description of the command
@param epilog: text to be printed after the options-help
@param examples: usage examples to be printed after the epilog
@param usage: Usage
@param interspersed: Is the command line allowed to be interspersed (options after the arguments)
@param args: Command line arguments when using the Application as a 'class' from a script
@param nr: Number of required arguments
@param changeVersion: May this application change the version of OF used?
@param exactNr: Must not have more than the required number of arguments
@param subcommands: parse and use subcommands from the command line. Either True or a list with subcommands
@param inputApp: Application with input data. Used to allow a 'pipe-like' behaviour if the class is used from a Script
@param localConfigurationFile: Use this file (or list of files) as a local configuration
@param findLocalConfigurationFile: Method to find a configuration file BEFORE the actual parameters are parsed
"""
global _LocalConfigurationFile
if _LocalConfigurationFile is not None:
configuration().addFile(_LocalConfigurationFile)
if isinstance(localConfigurationFile,string_types):
configuration().addFile(localConfigurationFile)
elif localConfigurationFile is not None:
for c in localConfigurationFile:
configuration().addFile(c)
if subcommands:
self.subs=True
if interspersed:
self.error("Subcommand parser does not work with 'interspersed'")
if subcommands==True:
subcommands=[]
self.parser=SubcommandFoamOptionParser(args=args,
description=description,
epilog=epilog,
examples=examples,
usage=usage,
subcommands=subcommands)
nr=None
exactNr=False
else:
self.subs=False
self.parser=FoamOptionParser(args=args,
description=description,
epilog=epilog,
examples=examples,
usage=usage,
interspersed=interspersed)
self.calledName=sys.argv[0]
self.calledAsClass=(args!=None)
if self.calledAsClass:
self.calledName=self.__class__.__name__+" used by "+sys.argv[0]
self.parser.prog=self.calledName
elif not _LocalConfigurationFile and findLocalConfigurationFile:
if args:
usedArgs=args
else:
usedArgs=sys.argv[1:]
_LocalConfigurationFile=findLocalConfigurationFile(usedArgs)
if _LocalConfigurationFile and not path.exists(_LocalConfigurationFile):
# Fix functions that do not check for the existence
_LocalConfigurationFile=None
if _LocalConfigurationFile:
configuration().addFile(_LocalConfigurationFile)
self.generalOpts=None
self.__appData=self.iDict()
if inputApp:
self.__appData["inputData"]=inputApp.getData()
grp=OptionGroup(self.parser,
"Default",
"Options common to all PyFoam-applications")
if changeVersion:
# the options are evaluated in Basics.FoamOptionParser
grp.add_option("--foamVersion",
dest="foamVersion",
default=None,
help="Change the OpenFOAM-version that is to be used. To get a list of know Foam-versions use the pyFoamVersion.py-utility")
if "WM_PROJECT_VERSION" in environ:
grp.add_option("--currentFoamVersion",
dest="foamVersion",
const=environ["WM_PROJECT_VERSION"],
default=None,
action="store_const",
help="Use the current OpenFOAM-version "+environ["WM_PROJECT_VERSION"])
grp.add_option("--force-32bit",
dest="force32",
default=False,
action="store_true",
help="Forces the usage of a 32-bit-version if that version exists as 32 and 64 bit. Only used when --foamVersion is used")
grp.add_option("--force-64bit",
dest="force64",
default=False,
action="store_true",
help="Forces the usage of a 64-bit-version if that version exists as 32 and 64 bit. Only used when --foamVersion is used")
grp.add_option("--force-debug",
dest="compileOption",
const="Debug",
default=None,
action="store_const",
help="Forces the value Debug for the WM_COMPILE_OPTION. Only used when --foamVersion is used")
grp.add_option("--force-opt",
dest="compileOption",
const="Opt",
default=None,
action="store_const",
help="Forces the value Opt for the WM_COMPILE_OPTION. Only used when --foamVersion is used")
grp.add_option("--force-system-compiler",
dest="foamCompiler",
const="system",
default=None,
action="store_const",
help="Force using a 'system' compiler (compiler installed in the system)")
grp.add_option("--force-openfoam-compiler",
dest="foamCompiler",
const="OpenFOAM",
default=None,
action="store_const",
help="Force using a 'OpenFOAM' compiler (compiler installed in ThirdParty)")
grp.add_option("--force-compiler",
dest="wmCompiler",
default=None,
action="store",
help="Overwrite value for WM_COMPILER (for instance Gcc47 ...)")
grp.add_option("--psyco-accelerated",
dest="psyco",
default=False,
action="store_true",
help="Accelerate the script using the psyco-library (EXPERIMENTAL and requires a separatly installed psyco)")
grp.add_option("--profile-python",
dest="profilePython",
default=False,
action="store_true",
help="Profile the python-script (not the OpenFOAM-program) - mostly of use for developers")
grp.add_option("--profile-cpython",
dest="profileCPython",
default=False,
action="store_true",
help="Profile the python-script (not the OpenFOAM-program) using the better cProfile library - mostly of use for developers")
grp.add_option("--profile-hotshot",
dest="profileHotshot",
default=False,
action="store_true",
help="Profile the python-script using the hotshot-library (not the OpenFOAM-program) - mostly of use for developers - DEPRECATED as this library will by removed from standard python and is no longer supported")
grp.add_option("--profile-line-profiler",
dest="profileLineProfiler",
default=False,
action="store_true",
help="Profile the python-script using the line_profiler-library (not the OpenFOAM-program) - mostly of use for developers - EXPERIMENTAL")
dbg=OptionGroup(self.parser,
"Debugging",
"Options mainly used for debugging PyFoam-Utilities")
dbg.add_option("--location-of-local-config",
dest="locationOfLocalConfig",
default=False,
action="store_true",
help="Prints the location of the found LocalConfigPyFoam-file that is used (if any)")
dbg.add_option("--traceback-on-error",
dest="traceback",
default=False,
action="store_true",
help="Prints a traceback when an error is encountered (for debugging)")
dbg.add_option("--interactive-debugger",
dest="interactiveDebug",
default=False,
action="store_true",
help="In case of an exception start the interactive debugger PDB. Also implies --traceback-on-error")
dbg.add_option("--catch-USR1-signal",
dest="catchUSR1Signal",
default=False,
action="store_true",
help="If the USR1-signal is sent to the application with 'kill -USR1 <pid>' the application ens and prints a traceback. If interactive debugging is enabled then the debugger is entered. Use to investigate hangups")
dbg.add_option("--also-catch-TERM-signal",
dest="alsoCatchTERMsignal",
default=False,
action="store_true",
help="In addition to USR1 catch the regular TERM-kill")
dbg.add_option("--keyboard-interrupt-trace",
dest="keyboardInterrupTrace",
default=False,
action="store_true",
help="Make the application behave like with --catch-USR1-signal if <Ctrl>-C is pressed")
dbg.add_option("--syntax-error-debugger",
dest="syntaxErrorDebugger",
default=False,
action="store_true",
help="Only makes sense with --interactive-debugger: Do interactive debugging even when a syntax error was encountered")
dbg.add_option("--i-am-a-developer",
dest="developerMode",
default=False,
action="store_true",
help="Switch on all of the above options. Usually this makes only sense if you're developing PyFoam'")
dbg.add_option("--interactive-after-execution",
dest="interacticeAfterExecution",
default=False,
action="store_true",
help="Instead of ending execution drop to an interactive shell (which is IPython if possible)")
grp.add_option("--dump-application-data",
dest="dumpAppData",
default=False,
action="store_true",
help="Print the dictionary with the generated application data after running")
grp.add_option("--pickle-application-data",
dest="pickleApplicationData",
default=None,
action="store",
type="string",
help="""\
Write a pickled version of the application data to a file. If the
filename given is 'stdout' then the pickled data is written to
stdout. The usual standard output is then captured and added to the
application data as an entry 'stdout' (same for 'stderr'). Be careful
with these option for commands that generate a lot of output""")
self.parser.add_option_group(grp)
self.parser.add_option_group(dbg)
self.addOptions()
self.parser.parse(nr=nr,exactNr=exactNr)
if len(kwArgs)>0:
self.parser.processKeywordArguments(kwArgs)
self.opts=self.parser.getOptions()
if self.subs:
self.cmdname=self.parser.cmdname
if self.opts.locationOfLocalConfig:
if _LocalConfigurationFile:
print_("Local configuration found at",
_LocalConfigurationFile)
else:
print_("No LocalConfigPyFoam-file found")
if "WM_PROJECT_VERSION" not in environ:
warning("$WM_PROJECT_VERSION unset. PyFoam will not be able to determine the OpenFOAM-version and behave strangely")
if self.opts.developerMode:
self.opts.syntaxErrorDebugger=True
self.opts.keyboardInterrupTrace=True
self.opts.alsoCatchTERMsignal=True
self.opts.catchUSR1Signal=True
self.opts.interactiveDebug=True
self.opts.traceback=True
if self.opts.interactiveDebug:
sys.excepthook=lambda a1,a2,a3:pyFoamExceptionHook(a1,
a2,
a3,
debugOnSyntaxError=self.opts.syntaxErrorDebugger)
self.opts.traceback=True
if self.opts.catchUSR1Signal:
import signal
signal.signal(signal.SIGUSR1,pyFoamSIG1HandlerPrintStack)
if self.opts.alsoCatchTERMsignal:
signal.signal(signal.SIGTERM,pyFoamSIG1HandlerPrintStack)
self.opts.traceback=True
if self.opts.keyboardInterrupTrace:
import signal
signal.signal(signal.SIGINT,pyFoamSIG1HandlerPrintStack)
self.opts.traceback=True
if self.opts.psyco:
try:
import psyco
psyco.full()
except ImportError:
warning("No psyco installed. Continuing without acceleration")
profOptions=sum([self.opts.profilePython,
self.opts.profileCPython,
self.opts.profileHotshot,
self.opts.profileLineProfiler])
if profOptions>0:
if profOptions>1:
self.error("Only one profiling option can be specified at a time")
print_("Running profiled")
fnAdd=""
if self.opts.profilePython:
import profile
elif self.opts.profileCPython:
import cProfile as profile
elif self.opts.profileLineProfiler:
import line_profiler
profile=line_profiler.LineProfiler(self.run)
import PyFoam.RunDictionary.SolutionDirectory
profile.add_module(PyFoam.RunDictionary.SolutionDirectory)
fnAdd=".lineProfiler"
else:
import hotshot
profileData=path.basename(sys.argv[0])+fnAdd+".profile"
if self.opts.profilePython or self.opts.profileCPython:
profile.runctx('self.run()',None,{'self':self},profileData)
print_("Reading python profile")
import pstats
stats=pstats.Stats(profileData)
elif self.opts.profileLineProfiler:
import inspect
nr=profile.add_module(inspect.getmodule(self))
self.warning("Adding",nr,"functions for line-profiling")
profile.runctx('self.run()',None,{'self':self})
profile.dump_stats(profileData)
profile.print_stats(open(profileData+".printed","w"))
stats=None
else:
profileData+=".hotshot"
prof=hotshot.Profile(profileData)
prof.runctx('self.run()',{},{'self':self})
print_("Writing and reading hotshot profile")
prof.close()
import hotshot.stats
stats=hotshot.stats.load(profileData)
if stats:
stats.strip_dirs()
stats.sort_stats('time','calls')
stats.print_stats(20)
self.parser.restoreEnvironment()
else:
try:
if self.opts.pickleApplicationData=="stdout":
# Redirect output to memory
from PyFoam.ThirdParty.six.moves import StringIO
oldStdout=sys.stdout
oldStderr=sys.stderr
sys.stdout=StringIO()
sys.stderr=StringIO()
result=self.run()
# do this at the earliest possible moment
self.parser.restoreEnvironment()
if self.opts.pickleApplicationData=="stdout":
# restore stdout
self.__appData["stdout"]=sys.stdout.getvalue()
self.__appData["stderr"]=sys.stderr.getvalue()
sys.stdout=oldStdout
sys.stderr=oldStderr
if self.opts.pickleApplicationData:
from PyFoam.ThirdParty.six.moves import cPickle as pickle
if self.opts.pickleApplicationData=="stdout":
pick=pickle.Pickler(sys.stdout)
else:
pick=pickle.Pickler(open(self.opts.pickleApplicationData,'wb'))
pick.dump(self.__appData)
del pick
if self.opts.dumpAppData:
import pprint
print_("Application data:")
printer=pprint.PrettyPrinter()
printer.pprint(self.__appData)
if self.opts.interacticeAfterExecution:
print_("\nDropping to interactive shell ... ",end="")
ns={}
ns.update(locals())
ns.update(globals())
try:
import IPython
print_("found IPython ...",end="")
if "embed" in dir(IPython):
print_("up-to-date IPython\n")
IPython.embed(user_ns=ns)
else:
print_("old-school IPython\n")
IPython.Shell.IPythonShellEmbed(argv="",user_ns=ns)()
except ImportError:
print_("no IPython -> regular shell\n")
from code import InteractiveConsole
c=InteractiveConsole(ns)
c.interact()
print_("\nEnding interactive shell\n")
return result
except PyFoamException:
e=sys.exc_info()[1]
if self.opts.traceback or self.calledAsClass:
raise
else:
self.errorPrint(str(e))
def conf(self):
"""Quick access to the configuration"""
return configuration().sectionProxy(self.name)
def conf(self):
"""Quick access to the configuration"""
return configuration().sectionProxy(self.name)
def addOptions(self):
what=OptionGroup(self.parser,
"What",
"Define what should be shown")
self.parser.add_option_group(what)
what.add_option("--dump",
action="store_true",
dest="dump",
default=False,
help="Dump the information as Python-dictionaries")
what.add_option("--disk-usage",
action="store_true",
dest="diskusage",
default=False,
help="Show the disk-usage of the case (in MB) - may take a long time")
what.add_option("--parallel-info",
action="store_true",
dest="parallel",
default=False,
help="Print information about parallel runs (if present): number of processors and processor first and last time. The mtime will be that of the processor-directories")
what.add_option("--no-state",
action="store_false",
dest="state",
default=True,
help="Don't read state-files")
what.add_option("--no-hostname",
action="store_false",
dest="hostname",
default=True,
help="Don't look up the hostname in the pickled data")
what.add_option("--advanced-state",
action="store_true",
dest="advancedState",
default=False,
help="Additional state information (run started, last output seen)")
what.add_option("--estimate-end-time",
action="store_true",
dest="estimateEndTime",
default=False,
help="Print an estimated end time (calculated from the start time of the run, the current time and the current simulation time)")
what.add_option("--start-end-time",
action="store_true",
dest="startEndTime",
default=False,
help="Start and end time from the controlDict")
what.add_option("--custom-data",
action="append",
dest="customData",
default=[],
help="Specification of additional data that is read from the pickled data-sets. The format is 'name=spec1::spec2::...' where 'name' is the name under which the data ist shown and 'specN' are the dictionary keys under which the data is accessed. If only 'spec1::spec2::..' is given then a name of the form 'CustomN' will be used. Can be specified more than once")
what.add_option("--solver-name-for-custom-data",
action="store",
dest="solverNameForCustom",
default=None,
help="This is used if '--custom-data' is specified as the data will be searched in 'PyFoamRunner.<solver name>.analyzed'. If unset then the utility will try to automatically determine the name of the solver which might be wrong")
what.add_option("--hg-info",
action="store_true",
dest="hgInfo",
default=False,
help="Looks for .hg in the directories and reports mercurial version info (for those who keep track of their cases with mercurial)")
how=OptionGroup(self.parser,
"How",
"How the things should be shown")
self.parser.add_option_group(how)
how.add_option("--sort-by",
type="choice",
action="store",
dest="sort",
default=configuration().get("CommandOptionDefaults","sortListCases",default="name"),
choices=self.sortChoices,
help="Sort the cases by a specific key (Keys: "+", ".join(self.sortChoices)+") Default: %default")
how.add_option("--reverse-sort",
action="store_true",
dest="reverse",
default=False,
help="Sort in reverse order")
how.add_option("--relative-times",
action="store_true",
dest="relativeTime",
default=False,
help="Show the timestamps relative to the current time")
behave=OptionGroup(self.parser,
"Behaviour",
"Additional output etc")
self.parser.add_option_group(behave)
behave.add_option("--progress",
action="store_true",
dest="progress",
default=False,
help="Print the directories while they are being processed")
behave.add_option("--no-progress-bar",
action="store_false",
dest="progressBar",
default=True,
help="Do not show a progress bar as directories are being processed")
behave.add_option("--dead-threshold",
action="store",
type="float",
dest="deadThreshold",
default=configuration().get("CommandOptionDefaults","deadThresholdListCases"),
help="Number of seconds without updates after which the case is assumed to be dead. Default: %default")
select=OptionGroup(self.parser,
"Selection",
"Select which cases should be shown. First the select-patterns are applied then the ignore patterns. If no select-patterns are specified then all cases are processed")
self.parser.add_option_group(select)
select.add_option("--recursive",
action="store_true",
dest="recursive",
default=False,
help="Recursively search for case directories")
select.add_option("--substring-select",
action="append",
dest="substringSelect",
default=[],
help="Substrings that should be in the case-name. Can be specified more than once")
select.add_option("--ignore-substring",
action="append",
dest="substringIgnore",
default=[],
help="Substrings that should not be in the case-name. Can be specified more than once")
select.add_option("--glob-select",
action="append",
dest="globSelect",
default=[],
help="Glob-pattern that the case-name should match. Can be specified more than once")
select.add_option("--no-glob-select",
action="append",
dest="globIgnore",
default=[],
help="Glob-pattern that the case-name should not match. Can be specified more than once")
def __init__(self,
args=None,
exactNr=True,
interspersed=True,
usage="%prog <caseDirectory>",
examples=None,
nr=1,
description=None,
**kwargs):
self.defaultMeshCreate=configuration().get("PrepareCase","MeshCreateScript")
self.defaultCaseSetup=configuration().get("PrepareCase","CaseSetupScript")
self.defaultParameterFile=configuration().get("PrepareCase","DefaultParameterFile")
description2="""\
Prepares a case for running. This is intended to be the replacement for
boiler-plate scripts. The steps done are
1. Clear old data from the case (including processor directories)
2. if a folder 0.org is present remove the 0 folder too
3. go through all folders and for every found file with the extension .template
do template expansion using the pyratemp-engine (automatically create variables
casePath and caseName)
4. create a mesh (either by using a script or if a blockMeshDict is present by
running blockMesh. If none of these is present assume that there is a valid mesh
present)
5. copy every foo.org that is found to to foo (recursively if directory)
6. do template-expansion for every file with the extension .postTemplate
7. execute another preparation script (caseSetup.sh)
8. do final template-expansion for every file with the extension .finalTemplate
The used parameters are written to a file 'PyFoamPrepareCaseParameters' and are used by other utilities
"""
examples2="""\
%prog . --paramter-file=parameters.base
Prepare the current case with the parameters list in parameters.base
%prog . --paramter-file=parameters.base --values-string="{'visco':1e-3}"
Changes the value of the parameter visco
%prog . --no-mesh-create
Skip the mesh creation phase
"""
PyFoamApplication.__init__(self,
args=args,
description=description if description else description2,
usage=usage,
examples=examples if examples else examples2,
interspersed=interspersed,
nr=nr,
exactNr=exactNr,
findLocalConfigurationFile=self.localConfigInArgs,
**kwargs)
