mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
177 lines
7.6 KiB
Python
177 lines
7.6 KiB
Python
from paraview import smtrace, servermanager, smstate
|
|
|
|
# boolean telling if we want to export rendering.
|
|
export_rendering = %1
|
|
|
|
# string->string map with key being the proxyname while value being the
|
|
# file name on the system the generated python script is to be run on.
|
|
reader_input_map = { %2 };
|
|
|
|
# list of views along with a file name and magnification flag
|
|
screenshot_info = {%3}
|
|
|
|
# the number of processes working together on a single time step
|
|
timeCompartmentSize = %4
|
|
|
|
# the name of the Python script to be outputted
|
|
scriptFileName = "%5"
|
|
|
|
|
|
class ReaderFilter(smtrace.PipelineProxyFilter):
|
|
def should_never_trace(self, prop):
|
|
if smtrace.PipelineProxyFilter.should_never_trace(self, prop): return True
|
|
# skip filename related properties.
|
|
return prop.get_property_name() in [\
|
|
"FilePrefix", "XMLFileName", "FilePattern", "FileRange", "FileName",
|
|
"FileNames"]
|
|
|
|
# -----------------------------------------------------------------------------
|
|
class ReaderAccessor(smtrace.RealProxyAccessor):
|
|
"""This accessor is created instead of the standard one for proxies that
|
|
are the temporal readers. This accessor override the
|
|
trace_ctor() method to trace the constructor as the RegisterReader() call,
|
|
since the proxy is a dummy, in this case.
|
|
"""
|
|
def __init__(self, varname, proxy, filenameglob):
|
|
smtrace.RealProxyAccessor.__init__(self, varname, proxy)
|
|
self.FileNameGlob = filenameglob
|
|
|
|
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
|
|
# FIXME: ensures thate FileName doesn't get traced.
|
|
|
|
# change to call STP.CreateReader instead.
|
|
ctor_args = "%s, fileInfo='%s'" % (ctor, self.FileNameGlob)
|
|
ctor = "STP.CreateReader"
|
|
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
|
|
self, ctor, ReaderFilter(), ctor_args, skip_assignment)
|
|
|
|
trace = smtrace.TraceOutput()
|
|
trace.append(original_trace)
|
|
trace.append(\
|
|
"timeSteps = %s.TimestepValues if len(%s.TimestepValues) != 0 else [0]" % (self, self))
|
|
return trace.raw_data()
|
|
|
|
# -----------------------------------------------------------------------------
|
|
class ViewAccessor(smtrace.RealProxyAccessor):
|
|
"""Accessor for views. Overrides trace_ctor() to trace registering of the
|
|
view with the STP. (I wonder if this registering should be moved to
|
|
the end of the state for better readability of the generated state files.
|
|
"""
|
|
def __init__(self, varname, proxy, screenshot_info):
|
|
smtrace.RealProxyAccessor.__init__(self, varname, proxy)
|
|
self.ScreenshotInfo = screenshot_info
|
|
|
|
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
|
|
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
|
|
self, ctor, filter, ctor_args, skip_assignment)
|
|
trace = smtrace.TraceOutput(original_trace)
|
|
trace.append_separated(["# register the view with coprocessor",
|
|
"# and provide it with information such as the filename to use,",
|
|
"# how frequently to write the images, etc."])
|
|
params = self.ScreenshotInfo
|
|
assert len(params) == 4
|
|
trace.append([
|
|
"STP.RegisterView(%s," % self,
|
|
" filename='%s', magnification=%s, width=%s, height=%s, tp_views)" %\
|
|
(params[0], params[1], params[2], params[3])])
|
|
trace.append_separator()
|
|
return trace.raw_data()
|
|
|
|
# -----------------------------------------------------------------------------
|
|
class WriterAccessor(smtrace.RealProxyAccessor):
|
|
"""Accessor for writers. Overrides trace_ctor() to use the actual writer
|
|
proxy name instead of the dummy-writer proxy's name.
|
|
"""
|
|
def __init__(self, varname, proxy):
|
|
smtrace.RealProxyAccessor.__init__(self, varname, proxy)
|
|
|
|
def get_proxy_label(self, xmlgroup, xmlname):
|
|
pxm = servermanager.ProxyManager()
|
|
prototype = pxm.GetPrototypeProxy(xmlgroup, xmlname)
|
|
if not prototype:
|
|
# a bit of a hack but we assume that there's a stub of some
|
|
# writer that's not available in this build but is available
|
|
# with the build used by the simulation code (probably through a plugin)
|
|
# this stub must have the proper name in the coprocessing hints
|
|
print "WARNING: Could not find", xmlname, "writer in", xmlgroup, \
|
|
"XML group. This is not a problem as long as the writer is available with " \
|
|
"the ParaView build used by the simulation code."
|
|
ctor = servermanager._make_name_valid(xmlname)
|
|
else:
|
|
ctor = servermanager._make_name_valid(prototype.GetXMLLabel())
|
|
# TODO: use servermanager.ProxyManager().NewProxy() instead
|
|
# we create the writer proxy such that it is not registered with the
|
|
# ParaViewPipelineController, so its state is not sent to ParaView Live.
|
|
return "servermanager.%s.%s" % (xmlgroup, ctor)
|
|
|
|
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
|
|
xmlElement = self.get_object().GetHints().FindNestedElementByName("WriterProxy")
|
|
xmlgroup = xmlElement.GetAttribute("group")
|
|
xmlname = xmlElement.GetAttribute("name")
|
|
|
|
filename = self.get_object().FileName
|
|
ctor = self.get_proxy_label(xmlgroup, xmlname)
|
|
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
|
|
self, ctor, filter, ctor_args, skip_assignment)
|
|
|
|
trace = smtrace.TraceOutput(original_trace)
|
|
trace.append_separated(["# register the writer with STP",
|
|
"# and provide it with information such as the filename to use"])
|
|
trace.append("STP.RegisterWriter(%s, '%s', tp_writers)" % \
|
|
(self, filename))
|
|
trace.append_separator()
|
|
return trace.raw_data()
|
|
|
|
class tpstate_filter_proxies_to_serialize(object):
|
|
"""filter used to skip views and representations a when export_rendering is
|
|
disabled."""
|
|
def __call__(self, proxy):
|
|
global export_rendering
|
|
if not smstate.visible_representations()(proxy): return False
|
|
if (not export_rendering) and \
|
|
(proxy.GetXMLGroup() in ["views", "representations"]): return False
|
|
return True
|
|
|
|
def tp_hook(varname, proxy):
|
|
global export_rendering, screenshot_info, reader_input_map
|
|
"""callback to create our special accessors instead of the default ones."""
|
|
pname = smtrace.Trace.get_registered_name(proxy, "sources")
|
|
if pname and reader_input_map.has_key(pname):
|
|
# this is a reader.
|
|
return ReaderAccessor(varname, proxy, reader_input_map[pname])
|
|
if pname and proxy.GetHints() and proxy.GetHints().FindNestedElementByName("WriterProxy"):
|
|
return WriterAccessor(varname, proxy)
|
|
if smtrace.Trace.get_registered_name(proxy, "views"):
|
|
# since view is being accessed, ensure that we were indeed saving
|
|
# rendering components.
|
|
assert export_rendering
|
|
return ViewAccessor(varname, proxy, screenshot_info[pname])
|
|
raise NotImplementedError
|
|
|
|
|
|
# Start trace
|
|
filter = tpstate_filter_proxies_to_serialize()
|
|
smtrace.RealProxyAccessor.register_create_callback(tp_hook)
|
|
state = smstate.get_state(filter=filter)
|
|
smtrace.RealProxyAccessor.unregister_create_callback(tp_hook)
|
|
|
|
output_contents = """
|
|
from paraview.simple import *
|
|
from paraview import spatiotemporalparallelism as STP
|
|
|
|
tp_writers = []
|
|
tp_views = []
|
|
|
|
timeCompartmentSize = %s
|
|
globalController, temporalController, timeCompartmentSize = STP.CreateControllers(timeCompartmentSize)
|
|
|
|
%s
|
|
|
|
STP.IterateOverTimeSteps(globalController, timeCompartmentSize, timeSteps, tp_writers, tp_views)
|
|
""" % (timeCompartmentSize, state)
|
|
|
|
|
|
outFile = open(scriptFileName, 'w')
|
|
outFile.write(output_contents)
|
|
outFile.close()
|