def __init__(self,
name,
parameters=[],
ordering=0,
initializer=None,
srepr=None,
tip=None,
discussion=None):
op = output.Output(name=name,
callback=self.opfunc,
otype=outputval.OutputValPtr,
instancefn=self.instancefn,
params=parameters,
srepr=srepr,
tip=tip,
discussion=discussion)
ArithmeticPropertyOutputRegistration.__init__(self, name, op,
initializer)
output.defineOutput(name, op, ordering=ordering)
compout = outputClones.ComponentOutput.clone(
name=name + " Component",
tip='Compute components of %s' % name,
discussion="""
<para>Compute the specified component of <link
linkend='Output-%s'>%s</link> on a &mesh;.</para>
""" % (name, name))
compout.connect('field', op)
for param in parameters:
compout.aliasParam('field:' + param.name, param.name)
output.defineOutput(name + ":Component", compout, ordering=ordering)
def __init__(self,
name,
parameters=[],
ordering=0,
initializer=None,
srepr=None,
tip=None,
discussion=None):
ScalarPropertyOutputRegBase.__init__(self, name, parameters, ordering,
initializer, srepr, tip,
discussion)
output.defineOutput(name, self.output, ordering=ordering)
def __init__(self,
name,
parameters=[],
ordering=0,
initializer=None,
srepr=None,
tip=None,
discussion=None):
op = output.Output(name=name,
callback=self.opfunc,
otype=outputval.OutputValPtr,
instancefn=self.instancefn,
srepr=srepr,
column_names=_symmmatrix3_column_names,
params=parameters,
tip=tip,
discussion=discussion)
ArithmeticPropertyOutputRegistration.__init__(self, name, op,
initializer)
output.defineOutput(name + ":Value", op, ordering=ordering)
def comprepr(s):
comp = s.resolveAlias("component").value
# We have to pass s to op.shortrepr so that the shortrepr
# will be computed for the actual Output, not the Output
# defined above. The actual output will be a clone of the
# one defined there.
return "%s[%s]" % (op.shortrepr(s), comp)
compout = outputClones.ComponentOutput.clone(
name=name + " Component",
tip='Compute components of %s' % name,
srepr=comprepr,
discussion="""
<para>Compute the specified component of %s on a &mesh;.</para>
""" % name)
compout.connect('field', op)
for param in parameters:
compout.aliasParam('field:' + param.name, param.name)
output.defineOutput(name + ":Component", compout, ordering=ordering)
def invariantrepr(s):
invariant = s.resolveAlias("invariant").value.shortrepr()
# See comment above about op.shortrepr(s)
return "%s(%s)" % (invariant, op.shortrepr(s))
invout = outputClones.InvariantOutput.clone(
name=name + " Invariant",
srepr=invariantrepr,
tip='Compute invariants of %s' % name,
discussion="""
<para>Compute the specified invariant of %s on a &mesh;.</para>
""" % name)
invout.connect('field', op)
for param in parameters:
invout.aliasParam('field:' + param.name, param.name)
output.defineOutput(name + ":Invariant", invout, ordering=ordering)
output.defineOutput(name + ":Invariant", invout, ordering=ordering)
def __init__(self,
name,
symbol,
parameters=[],
initializer=None,
ordering=1,
tip=None,
discussion=None):
self.symbol = symbol
op = output.Output(name=name,
callback=self.opfunc,
otype=outputval.ListOutputValPtr,
instancefn=self.instancefn,
srepr=_threevector_srepr,
column_names=_threevector_column_names,
params=parameters,
tip=tip,
discussion=discussion,
symbol=symbol)
NonArithmeticPropertyOutputRegistration.__init__(
self, name, op, initializer)
output.defineOutput(name, op, ordering=ordering)
def __init__(self,
name,
parameters=[],
ordering=0,
initializer=None,
tip=None,
discussion=None):
param = enum.EnumParameter("format",
orientationmatrix.OrientationEnum,
tip="How to print the orientation.")
op = output.Output(name=name,
callback=self.opfunc,
otype=corientation.COrientationPtr,
instancefn=self.instancefn,
srepr=_orientation_srepr,
column_names=_orientation_column_names,
params=[param] + parameters,
tip=tip,
discussion=discussion)
NonArithmeticPropertyOutputRegistration.__init__(
self, name, op, initializer)
output.defineOutput(name, op, ordering=ordering)
name="difference",
callback=_difference,
otype=outputval.OutputValPtr,
srepr=_difference_shortrepr,
instancefn=_difference_instancefn,
column_names=_aggdiff_column_names,
params=[
output.ValueOutputParameter(
'minuend',
tip='The quantity from which the subtrahend is subtracted.'),
output.ValueOutputParameter(
'subtrahend', tip='The quantity to subtract from the minuend.')
],
tip="Compute the difference between two quantities.")
output.defineOutput('Difference', AggregateDifferenceOutput, ordering=1000)
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
# The Concatenate Output allows two Outputs to be printed on the same
# line of the output file. Its value type is the
# ConcatenatedOutputVal class, which defines a bunch of arithmetic
# operations that it just passes through to the OutputVals that it's
# concatenating. ConcatenatedOutputVal is itself *not* an OutputVal.
# Maybe it should be, but that would mean defining it in C++.
## TODO: Allow more than two outputs to be concatenated, so that it's
## not necesary to nest the concatenations. We'll need a Parameter
## class for multiple Outputs, and a widget for it.
## ConcatenatedOutputVal can already handle more than two, but
## Concatenate can't.
# played by the MeshNodePosition class.
######################
## Is there any point in outputting the surface normal? Maybe if
## it were computed using displaced coordinates...
# output.defineOutput("Surface Normal",
# outputClones.SurfaceNormalOutput,
# ordering=500)
normalFluxOutput = outputClones.DotProduct.clone(
name="Flux Normal"
)
normalFluxOutput.connect('a', outputClones.FluxOutput)
normalFluxOutput.connect('b', outputClones.SurfaceNormalOutput)
normalFluxOutput.aliasParam('a:flux', 'flux')
output.defineOutput("Flux:Normal:Value", normalFluxOutput, ordering=100)
normalFluxInvariantOutput = outputClones.InvariantOutput.clone(
name="flux normal invariant",
tip="Compute invariants of Flux normals at a surface.")
normalFluxInvariantOutput.connect("field", normalFluxOutput)
normalFluxInvariantOutput.aliasParam('field:flux', 'flux')
output.defineOutput("Flux:Normal:Invariant", normalFluxInvariantOutput,
ordering=101)
######################
output.defineOutput('Field:Value', outputClones.FieldOutput,
ordering=1.0)
output.defineOutput('Field:Derivative:Value', outputClones.FieldDerivOutput,
ordering=1.1)
name="difference",
callback=_difference,
otype=outputval.OutputValPtr,
srepr=_difference_shortrepr,
instancefn=_difference_instancefn,
column_names=_aggdiff_column_names,
params=[
output.ValueOutputParameter(
'minuend',
tip='The quantity from which the subtrahend is subtracted.'),
output.ValueOutputParameter(
'subtrahend', tip='The quantity to subtract from the minuend.')
],
tip="Compute the difference between two quantities.")
output.defineOutput('Difference', AggregateDifferenceOutput, ordering=1000)
#=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=#
# Scale values to lie between 0 and 1.
def _rescaleOutput(mesh, elements, coords, minimum, maximum, inputdata):
minval = min(inputdata)
maxval = max(inputdata)
# TODO OPT: Doing this math in python on ScalarOutputVals is
# inefficient. Can it be done in C++ instead? This is a low
# priority until this function is actually used.
def rescale(x, mn=minval, mx=maxval, tmin=minimum, tmax=maximum):
if mx == mn: