[Back] [Up] [Next]

## Built-in expressions

The following table lists built-in expressions that can be used to create more advanced expressions. Unless otherwise noted in the description, each expression takes scalar variables as its arguments.

Expression | Meaning | Usage
--- | --- | ---
{} | Associate a list of expressions into a single variable. Usually used for defining a vector or tensor variable. | {expr 1, expr 2 [, ...]} expri expr 1 expr1 can be an expression of variables, another expression, or a constant defined over a mesh. Examples: vector = {a,b,c} tensor = {{a,b,c},{d,e,f},{g,h,i}}
[] | Access a subscript of a vector or tensor variable. | expr[index] expr must be an expression that evaluates to a vector of tensor variable and index must be an integer greater than or equal to zero and less than the number of components in the variable being indexed. Example: velocity[0]
() | Associative parenthesis. | Group mathematical operations to influence the order in which expressions are evaluated.
- | Unary negation | -expr expr is any expression that evaluates to a scalar or vector field defined on a mesh. Example: -charge
- | Subtraction | expr 1 - expr 2 expressions involving subtraction can be database variables, constants, or other expressions. Example: a - b
+ | Addition | expr 1 + expr 2 Expressions involving addition can be database variables, constants, or other expressions. Example: a + b
* | Multiplication | expr 1 * expr 2 Expressions involving multiplication can be database variables, constants, or other expressions. Multiplication is most often used with two scalar inputs but one of the inputs to the multiplication operator can be a vector if you want to scale a vector using a scalar or a constant. Example: a * b
/ | Division | expr 1 / expr 2 Expressions involving division can be database variables, constants, or other expressions. Division is most often used with two scalar inputs but the first input can be a vector if you want to scale a vector using a scalar or a constant. Example: a / b
^ | Exponentiation | expr 1 ^ expr 2 Expressions involving exponentiation can be database variables, constants, or other expressions. Example: a ^ b
abs | Absolute value | abs(expr) expr can be an expression of database variables, constants, or other scalar expressions.
acos | Arccosine | acos(expr) expr can be an expression of database variables, constants, or other scalar expressions. The acos expression returns an angle in radians. Example: angle = acos(value)
and | Logical and | and(expr 1, expr 2) The logical and function returns a value of 1 (true) if both scalar input expressions expr1 and expr2 are not equal to zero. Otherwise, the logical and function returns zero. The logical and function is often used with other conditionals such as the if expression. Example: if(and(gt(pressure, 2.0), lt(pressure, 4.0)), pressure, 0.0) Meaning: if pressure is in the range (2.0, 4.0) then use the value for pressure. Otherwise, use zero.
area | Cell Area | area(expr) expr must evaluate to a 2D mesh expression so VisIt can calculate the area of each 2D cell in the mesh and returns scalar values. Example: density = mass / area(hydro_mesh2d)
array_compose | Array compose | array_compose(expr 1, expr 2, ..., expr N) Each argument to the array_compose expression, expri, must evaluate to a scalar expression and all of the input expressions must have the same centering. The array_compose expression creates a new array variable from the input expressions. Array variables are collections of scalar variables that are commonly used with certain plots to display the contents of multiple variables simultaneously. For example, the Label plot can display the values in an array variable. Example: array_compose(density, pressure, velocity[0], velocity[1], velocity[2])
array_decompose | Array decompose | array_decompose(expr 1, expr 2) expr1 must evaluate to an array variable. expr2 must evaluate to a number between 0 and the number of scalar components in the array variable minus 1. This expression isolates one scalar variable from an array variable. Example: array_decompose(array, 0)
asin | Arcsine | asin(expr) expr can be an expression of database variables, constants, or other scalar expressions. The asin expression returns an angle in radians. Example: angle = asin(value)
aspect | Cell aspect ratio | aspect(expr) expr must be an expression that evaluates to a mesh. The aspect function computes the aspect ratio for each cell in the mesh and returns scalar values. Cells with high aspect ratios (long and skinny) are often considered to be less fit than more squat cells. Example: aspect(hydro_mesh)
aspect_gamma | Cell aspect gamma | aspect_gamma(expr) expr must be an expression that evaluates to a mesh. Example: aspect_gamma(hydro_mesh)
atan | Arctangent | atan(expr) expr can be an expression of database variables, constants, or other scalar expression variables. The atan expression returns an angle in radians. Example: angle = atan(value)
ceil | Ceiling | ceil(expr) expr must evaluate to a scalar expression. The ceil expression calculates the ceiling function. The ceiling is defined to be smallest integer that is bigger than the current value. Example: ceil(pressure)
condition | Condition number | condition(expr) expr must be an expression that evaluates to a mesh. The condition expression returns the maximum condition number of the Jacobian matrix at the nodes of each cell in the mesh, resulting in a zone-centered, scalar expression. Example: condition(hydro_mesh)
conn_cmfe | Connectivity-based common mesh field evaluation | conn_cmfe(expr 1, expr 2) expr1 is an expression commonly from a different database and it contains the field that will be mapped onto the mesh expression that is created by expr2. The conn_cmfe expression is used to map variables from one mesh onto another mesh. The mesh that donates the field being mapped can be a different time state of the same database or it can be in a different file than the destination mesh. You can use the conn_cmfe expression to compare the results from different simulation runs. For more information on using the conn_cmfe expression, see page 292. Examples: Map wave0020.silo's pressure variable the current mesh. conn_cmfe(<wave0020.silo:pressure>, quadmesh) Substract <mesh/ireg> variable from the last time state from the current time state. <mesh/ireg> - conn_cmfe(<allinone00.pdb[-1]id:mesh/ireg>, mesh)
conservative_smooth | Conservative smooth | conservative_smooth(expr) expr must be an expression that evaluates to a scalar field. This expression applies the conservative smooth filter (an image processing filter) to a scalar field. The filter only considers a value and its immediate neighbors (26 neighbors in three dimensions, 8 in two dimensions). The filter only works on structured meshes. When performing a conservative smooth operation, a value is only replaced if it is outside the range of its immediate neighbors. If so, it is replaced with the closest value from its immediate neighbors. Example: conservative_smooth(intensity)
coord, coords | Mesh coordinates | coord(expr) expr must be an expression that evaluates to a mesh. The coord expression extracts the coordinate fields from a mesh and returns them as a vector variable with 3 components. The resulting vector can be used to extract the x,y,z components of the mesh's coordinate field. Example: x = coord(Mesh)[0]
cos | Cosine | cos(expr) Compute the cosine of an angle in radians. Expr can be an expression of database variables, constants, or other scalar expression that evaluate to an angle in radians. The cos expression returns a scalar expression. Example: x = radius * cos(angle)
cross | Vector cross product | cross(expr 1, expr 2) The cross expression returns the vector cross product of the expr1 and expr2 vector expressions. Example: viewvec = cross(right_vec, up_vec)
curl | Curl | curl(expr) The curl expression calculates the curl of the input expression, which must evaluate to a vector field. The result is also a vector unless the input data is 2D. When the input data set is 2D, the resulting curl vector always is (0,0,V) so the curl expression instead returns the scalar V. The curl expression must be declared as a vector for 3D data sets, but as a scalar for 2D data sets. Example: curl(vecfield)
cylindrical_radius | Cylindrical radius | cylindrical_radius(expr) expr must be an expression that evaluates to a mesh. The cylindrical radius expression converts the coordinates of the input mesh from cartesian coordinates to cylindrical coordinates and returns the radius component of the cylindrical coordinates. Example: cylindrical_radius(hydro_mesh)
cylindrical_theta | Cylindrical theta | cylindrical_theta(expr) expr must be an expression that evaluates to a mesh. The cylindrical theta expression converts the coordinates of the input mesh from cartesian coordinates to cylindrical coordinates and then returns the theta component of the cylindrical coordinates. Example: cylindrical_theta(hydro_mesh)
deg2rad | Degrees to radians | deg2rad(expr) The deg2rad expression converts the input scalar expression, which is assumed to be in degrees, to radians. Example: angle_rad = deg2rad(angle)
degree | Mesh degree | degree(expr) expr must be an expression that evaluates to a mesh. The degree expression creates a nodal scalar field that contains the number of cells that use each node. Example: degree(Mesh)
det, determinant | Matrix determinant | determinant(expr) expr must evaluate to a 3x3 tensor. The determinant expression computes the determinant of a 3x3 matrix and returns the scalar result. Expression: detA = determinant(A)
diagonal | Diagonal ratio | diagonal(expr) expr must be an expression that evaluates to a mesh. The diagonal expression computes the minimum and maximum diagonals for 3D hexahedral cells and returns the minimum diagonal length divided by the maximum diagonal length. Cells that have equal aspect ratios will have diagonal ratios of 1.0 while more oblong cells will have differing values. For cells that are not hexahedral, the diagonal expression returns -1. Example: diagonal(Mesh)
dimension | Pronto-specific length of stable time step | dimension(expr) expr must be an expression that evaluates to a mesh. The dimension expression computes the characteristic length for stable time step calculation in the Pronto simulation code. Example: dimension(Mesh)
divergence | Divergence | divergence(expr) The divergence filter calculates the divergence, which is the tendency of a fluid to spread out. The input expression must evaluate to a vector field. Divergence results in a scalar field. Example: divergence(vec)
dot | Vector dot product | dot(expr 1, expr 2) The dot expression takes 2 vector inputs expr1 and expr2 and computes their vector dot product and returns the resulting scalar expression. Example: dot(vector1, vector2)
effective_tensor | Effective tensor | effective_tensor(expr) expr must evaluate to a tensor expression. The effective_tensor expression determines the effective part of a 3x3 tensor and returns the resulting scalar expression. Example: effective_tensor(tensor1)
eigenvalue | Eigenvalue | eigenvalue(expr) expr must evaluate to a 3x3 tensor. The eigenvalue expression returns the eigenvalues of the 3x3 matrix argument as a vector valued expression where each eigenvalue is a component of the vector. Use the component index operator ('[]') to access individual eigenvalues. Example: evals = eigenvalue(tensor), evals[0]
eigenvector | Eigenvector | eigenvector(expr) expr must evaluate to a 3x3 tensor. The eigenvector expression returns the eigenvectors of the 3x3 matrix argument as a tensor (3x3 matrix) valued expression where each row in the tensor is one of the eigenvectors. Use the component index operator ('[]') to access individual eigenvectors. Example: evecs = eigenvector(tensor), evecs[1]
eq, equal, equals | Equality | equal(expr 1, expr 2) The equal expression returns a value of 1 (true) if both input scalar expressions expr1 and expr2 are equal. Otherwise, the equal expression returns zero. The equal expression is often used with other conditionals such as the if expression. Example: if(eq(density, 1.0), density*2.0, 0.0)
external_node | External node | external_node(expr) The external_node expression marks every node that is incident to an external face as '1', every node incident to only internal faces as '0'. Expr must be a mesh. If expr is a two-dimensional mesh, then the expression returns '1' if a node is incident to an external edge. Example: external_node(hydro_mesh)
floor | Floor | floor(expr) expr must be an expression that evaluates to a scalar expression. The floor expression takes the floor of its expression argument, which is defined to be biggest integer that is smaller than the current value. Example: floor(pressure)
ge, gte | Greater than or equal | ge(expr 1, expr 2) The ge expression returns a value of 1 (true) if expr1 >= expr2. Both input expressions must be scalar expressions. Example: if(ge(pressure, density), 1.0, 0.0)
global_nodeid | Global node numbers | global_nodeid(expr) The global_nodeid expression returns a scalar field containing the global node numbers for a domain-decomposed mesh so that each node in the mesh is numbered such that it is part of the whole mesh. expr can be any expression that ultimately involves a single mesh. Example: global_nodeid(MESH) N = global_nodeid(x)
global_zoneid | Global zone numbers | global_zoneid(expr) The global_zonid expression returns a scalar field containing the global cell numbers for a domain-decomposed mesh so that each cell in the mesh is numbered such that it is part of the whole mesh. expr can be any expression that ultimately involves a single mesh. Example: global_zoneid(MESH) N = global_zoneid(x)
gradient | Gradient | gradient(expr) The gradient expression computes the gradient, which results in a vector expression, from expr, which must evaluate to a scalar expression. The gradient calculation method varies depending on the type of the mesh over which the input is defined. Example: volume_normals = gradient(vals)
gt | Greater than | gt(expr 1, expr 2) The gt expression returns a value of 1 (true) if expr1 > expr2. Both input expressions must be scalar expressions. Example: density = mass / if(gt(volume, 0.0), volume, 0.00001)
if | Conditional | if(expr 1, expr 2, expr 3) The if expression is used to select values based on a condition. Expr1 must evaluate to a scalar. When expr1's values are not equal to zero then the condition is true and the if expression returns the value for expr2. When expr1's values are equal to zero, values for expr3 are returned. Example: inv_pressure = 1.0 / if(gt(pressure,0.0), pressure, 0.001)
inverse | Matrix inverse | inverse(expr) expr must evaluate to a 3x3 tensor expression. The inverse expression calculates the matrix inverse of the input matrix. Example: invA = inverse(A)
jacobian | Jacobian | jacobian(expr) expr must be an expression that evaluates to a mesh. The jacobian expression returns a scalar expression. Example: jacobian(hydro_mesh)
laplacian, Laplacian | Laplacian | laplacian(expr) expr must be an expression that evaluates to a scalar. The laplacian expression returns a scalar expression containing the Laplacian of the input scalar field. Example: Laplacian(pressure)
largest_angle | Largest angle | largest_angle(expr) expr must be an expression that evaluates to a 2D mesh. The largest_angle expression calculates a cell-centered scalar field containing the value of the largest interior angle in degrees. Only triangle and quadrilateral cells are considered. Example: largest_angle(hydro_mesh)
le, lte | Less than or equal | le(expr 1, expr 2) The le expression returns a value of 1 (true) if expr1 <= expr2. Both input expressions must be scalar expressions. Example: if(le(pressure, density), 1.0, 0.0)
ln | Natural logarithm | ln(expr) expr can be a database variable, constant, or other scalar expression. The ln expression computes the natural logarithm of the input scalar expression. Example: ln(density)
log, log10 | Base 10 logarithm | log(expr) expr can be a database variable, constant, or other scalar expression. The log expression computes the base 10 logarithm of the input scalar expression. Example: log(density)
lt | Less than | lt(expr 1, expr 2) The le expression returns a value of 1 (true) if expr1 < expr2. Both input expressions must be scalar expressions. Example: if(lt(pressure, density), 1.0, 0.0)
magnitude | Vector magnitude | magnitude(expr) expr can be a database variable, constant, or other vector expression. The magnitude expression computes the magnitude of the vector and returns a scalar expression. Example: magnitude(vector1)
materror | Material error | materror(expr 1, expr 2) expr1 must be an expression that evaluates to a material. expr2 must be an identifier for the name of a material, which can be either numeric or a string constant matching the name of a material in the database. The materror expression computes the difference between the volume fractions stored in the database and those that were used by VisIt's material reconstruction algorithm. Example: materror(mat1, 1)
matvf | Material volume fraction | matvf(expr 1, expr 2) expr1 must be an expression that evaluates to a material. expr2 must be an identifier for the name of a material, which can either be numeric or can be a string constant matching the name of a material in the database. The matvf expression extracts the material volume fractions from a material for a specified material name and returns the results in a scalar expression. Examples: percent_chrome = matvf(mat1, "2 chrome") percent_1 = matvf(Material, 1)
max_edge_length | Maximum edge length | max_edge_length(expr) expr must be an expression that evaluates to a mesh. The max_edge_length expression calculates the edge length for each edge in a cell, assigning the length of the longest edge to the entire cell. Example: max_edge_length(hydro_mesh)
max_side_volume | Maximum side volume | max_side_volume(expr) expr must be an expression that evaluates to a three-dimensional mesh. The max_side_volume expression calculates the side volume for each side in a cell, assigning the value of the biggest side volume to the entire cell. A "side" is a tetrahedron that covers one edge of a cell plus parts of the surrounding faces.When a cell has negative side volume, it is usually twisted. Example: max_side_volume(hydro_mesh)
mean | Mean | mean(expr) expr must evaluate to a scalar expression. The mean expression calculates the mean average of a scalar field. The mean is calculated using the value and its immediate neighbors. The mean expression only considers the value and its 26 neighbors in three dimensions, or just the eight neighbors in two dimensions. This expression only works on structured meshes. Example: mean(intensity)
median | Median | median(expr) expr must evaluate to a scalar expression. The median expression Calculates the median of a scalar field. The median is calculated using the value and its immediate neighbors. The median expression only considers the value and its 26 neighbors in three dimensions, or just the eight neighbors in two dimensions. This expression only works on structured meshes. Example: median(intensity)
min_edge_length | Minimum edge length | min_edge_length(expr) expr must be an expression that evaluates to a mesh. The min_edge_length expression calculates the edge length for each edge in a cell, assigning the length of the smallest edge to the entire cell. Example: min_edge_length(hydro_mesh)
min_side_volume | Minimum side volume | min_side_volume(expr) expr must be an expression that evaluates to a three-dimensional mesh. The min_side_volume expression calculates the side volume for each side in a cell, assigning the value of the smallest side volume to the entire cell. A "side" is a tetrahedron that covers one edge of a cell plus parts of the surrounding faces. When a cell has negative side volume, it is usually twisted. Example: max_side_volume(hydro_mesh)
mirvf | Material interface reconstruction volume fraction | mirvf(expr 1, expr 2, expr 3, expr 4) expr1 must be an expression that evaluates to a material. expr2 must be an expression that evaluates to a scalar field containing the zone id's for the mesh. expr3 must be an expression variable that evaluates to a scalar field containing the volumes or areas of each cell in the mesh. expr4 must be an expression that evaluates to a list of material names or numbers. The mirvf expression returns the volume fractions computed by VisIt's material interface reconstruction algorithm. The volume fractions computed by VisIt's material interface reconstruction algorithm do not always match what is stored in the database because VisIt's algorithm strives to maintain continuous interfaces rather than accuracy. Example: mirvf(mat1, zoneid(curvmesh2d), area(curvmesh2d), [1])
mod | Modulo | mod(expr 1, expr 2) expr1 and expr2 must be expressions that evaluate to integer scalar fields. The mod expression calculates expr1 modulo expr2. This expression is typically used in conjunction with the expressions ceil, floor, or round. Example: mod(var1, var2)
neighbor | Neighbor | neighbor(expr) expr must be an expression that evaluates to a mesh. Neighbor creates a node-centered scalar on a point mesh representation of the original mesh. Expression: neighbor(hydro_mesh)
nmats | Number of materials | nmats(expr) expr must be an expression that evaluates to a material. The nmats expression creates a cell-centered scalar variable containing the number of materials in each cell. This expression can be used with the Threshold operator to remove cells that do not have a desired number of materials. Example: nmats(material)
node_degree | Node degree | node_degree(expr) expr must be an expression that evaluates to a mesh. The node_degree expression calculates how many edges each node it part of and stores that value as a node-centered scalar expression. Example: node_degree(MESH)
nodeid | Node number | nodeid(expr) expr can be any expression that involves a single mesh. The nodeid expression creates a node-centered scalar field containing the node index of each mode in the mesh. The nodeid expression's primary use is in debugging VisIt plots. Example: nodeid(MESH)
not | Logical not | not(expr) expr must be a database variable, constant, or other scalar expression. The not expression returns 1 (true) if the input expression equals zero and zero otherwise. Expression: outside = not(inside)
notequal, notequals. ne | Not equal | notequal(expr 1, expr 2) The notequal expression returns 1 (true) if expr1 != expr2 and zero otherwise. Both expr1 and expr2 must be scalar expressions. Example: if(notequal(mass, 12.3), 1, 0)
oddy | General distortion measure | oddy(expr) expr must be an expression that evaluates to a mesh. The oddy expression calculates a general distortion measure based on the left Cauchy-Green tensor. Example: oddy(MESH)
or | Logical or | or(expr 1, expr 2) The logical or expression returns a value of 1 (true) either of the scalar input expressions expr1 and expr2 are not equal to zero. If both input expressions are equal to zero then the expression returns zero. The logical or expression is often used with other conditionals such as the if expression. Example: if(or(lt(pressure, 2.0), gt(pressure, 4.0)), pressure, 0.0) Meaning: if pressure is in the range (,2.0) or (4.0, ) then use the value for pressure. Otherwise, use zero.
polar | Convert to polar coordinates | polar(expr) expr must be a database variable, constant, or other vector expression. The polar expression converts a vector, which is assumed to represent cartesian coordinates (x, y, z), into polar coordinates (r, theta, phi). Example: vec = polar(coord(MESH))
polar_phi | Phi component of polar coordinate representation of mesh. | polar_phi(expr) expr must evaluate to a mesh. The polar_phi expression converts the coordinates of the input mesh from cartesian coordinates to polar coordinates and then returns the phi component of the cylindrical coordinates. Example: polar_phi(hydro_mesh)
polar_radius | Radius component of polar coordinate representation of mesh. | polar_radius(expr) expr must evaluate to a mesh. The polar_radius expression converts the coordinates of the input mesh from cartesian coordinates to polar coordinates and then returns the radius component of the cylindrical coordinates. Example: polar_radius(hydro_mesh)
polar_theta | Theta component of polar coordinate representation of mesh. | polar_theta(expr) expr must evaluate to a mesh. The polar_theta expression converts the coordinates of the input mesh from cartesian coordinates to polar coordinates and then returns the theta component of the cylindrical coordinates. Example: polar_theta(hydro_mesh)
principal_deviatoric_tensor | Principal deviatoric vector of tensor | principal_deviatoric_tensor(expr) expr can be a database variable, constant, or other 3x3 tensor expression. The principal_tensor computes the deviatoric principals of a tensor, which result in a vector expression. Example: principal_deviatoric_tensor(tensor1)
principal_tensor | Principals of tensor | principal_tensor(expr) expr can be a database variable, constant, or other 3x3 tensor expression. The principal_tensor computes the principals of a tensor, which result in a vector expression. Example: principal_tensor(tensor1)
procid | Processor Rank | procid(expr) expr must be an expression that evaluates to a mesh. The procid expression returns the processor rank of the compute engine that is handling the current domain of the specified mesh. Example: pid = procid(MESH)
rad2deg | Radians to degrees | rad2deg(expr) The rad2deg expression converts the input scalar expression, which is assumed to be in radians, to degrees. Example: angle_deg = rad2deg(angle)
random, rand | Random number | random(expr) expr must be an expression that evaluates to a mesh. The random expression creates a scalar field over the specified mesh where each node in the mesh gets a different random number in the range: [0,1]. Example: random(MESH)
recenter | Recenter variable | recenter(expr) expr must be a database variable or other expression that eventually involves a database variable. Two common types of variable centering are cell-centered and node-centered. The recenter expression switches the centering for the input expression. Use the recenter expression to explicitly force a specific variable centering or to make another variable. Example: density + recenter(temp)
relative_difference | Relative difference | relative_difference(expr 1, expr 2) The relative_difference expression computes the relative difference between two scalar expressions using the following formula: if (A == B && A == 0) then 0. else (A-B) / (abs(A) + abs(B)) Example: relative_difference(x,y)
relative_size | Relative cell size | relative_size(expr) expr must be an expression that evaluates to a mesh. The relative_size calculates the relative size of cells in the mesh by finding the minimum value of J or 1/J where J is the determinant of a weighted Jacobian matrix. Example: relative_size(MESH)
revolved_surface_area | Revolved surface area | revolved_surface_area(expr) expr must be an expression that evaluates to a 2D mesh. The revolved_surface_area expression revolves triangle and quad cells about the X-axis and calculates the surface area of the revolved cell. The result is a cell-centered scalar expression. Example: revolved_surface_area(mesh2d)
revolved_volume | Revolved cell volume | revolved_volume(expr) expr must be an expression that evaluates to a 2D mesh. The revolved_volume expression calculates the volume of a triangle or quad cell revolved about the X-axis. The result is a cell-centered scalar expression. Example: vol = revolved_volume(mesh2d)
round | Round | round(expr) expr must be an expression that evaluates to a scalar expression. The round expression rounds the value of its expression argument to the nearest integer value. If two integers are equally close then the round expression rounds up. For example, 8.5 gets rounded up to 9. Example: round(pressure)
scaled_jacobian | Scaled jacobian | scaled_jacobian(expr) expr must be an expression that evaluates to a mesh. The scaled jacobian expression calculates a scalar expression based on the minimum of the Jacobian divided by the lengths of a cell's edge vectors. Example: scaled_jacobian(MESH)
shape | Cell shape | shape(expr) expr must be an expression that evaluates to a mesh. The shape expression calculates 2 divided by the condition number of the weighted Jacobian matrix. Example: shape(MESH)
shape_and_size | Cell shape and size | shape_and_size(expr) expr must be an expression that evaluates to a mesh. The shape_and_size expression calculates the shape and size expressions and multiplies their values. Example: shape_and_size(MESH)
shear | Shear | shear(expr) expr must be an expression that evaluates to a mesh. The shear expression calculates mesh shear and results in a scalar expression. Example: shear(MESH)
sin | Sine | sin(expr) Compute the sine of an angle in radians. Expr can be an expression of database variables, constants, or other scalar expression that evaluate to an angle in radians. The sin expression returns a scalar expression. Example: y= radius * sin(angle)
skew | Mesh skew | skew(expr) expr must be an expression that evaluates to a mesh. The skew expression calculates the skew for each cell in the mesh and stores the result in a cell-centered scalar expression. The skew is the maximum |cosA| where A is the angle between the edges at the cell center. Cells with high skew are generally created in error. Example: skew(MESH)
smallest_angle | Smallest angle | smallest_angle(expr) expr must be an expression that evaluates to a 2D mesh. The smallest_angle expression calculates a cell-centered scalar field containing the value of the smallest interior angle in degrees. Only triangle and quadrilateral cells are considered. Example: smallest_angle(hydro_mesh)
specmf | Species mass fraction | specmf(expr 1, expr 2, expr 3 [, expr 4]) The specmf expression extracts the mass fractions for a material species from a species variable and returns a mesh-sized scalar field that can be used in other expressions or plotted. expr1 must a species variable; the default name for a species variable is: Species. expr2 must be a single material number or material name. expr3 must be a single species name or number or list of species names or numbers for the given material. Lists of species are enclosed in square brackets [] and are comma-separated. The expr4 argument is optional and is a boolean value that weights the species masses by the material volume fraction if it is set to true. When expr4 is not provided, its value is assumed to be false. Example: specmf(Species, "Air", "Argon")
sq, sqr | Square | sqr(expr) expr can be a database variable, constant, or other scalar expression. The sqr expression multiplies the input values by themselves, squaring them. Example: x_times_x = sqr(x)
sqrt | Square root | sqrt(expr) expr can be a database variable, constant, or another scalar expression. The sqrt expression computes the square root of the input expression. Example: dist = sqrt(x*x + y*y + z*z)
stretch | Cell stretch | stretch(expr) expr must be an expression that evaluates to a mesh. The stretch expression calculates the square root of 3 times the minimum edge length divided by the maximum diagonal length. Stretch is only calculated for hex and quad cells. Example: stretch(HexMesh)
surface_normal | Surface normal | surface_normal(expr) Calculates the direction normal to each vertex. This incorporates the normal directions of each face a vertex is incident to. Expr must be a mesh that is a three dimensional surface. Note that you will have to apply the ExternalSurface operator and the DeferExpression operator in order for the surface_normal expression to be evaluated on the plot as it is displayed in the visualization window. Example: surface_normal(surface_mesh)
tan | Tangent | tan(expr) Compute the tangent of an angle in radians. Expr can be an expression of database variables, constants, or other scalar expression that evaluate to an angle in radians. The tan expression returns a scalar expression. Example: y = radius * sin(angle)
taper | Mesh taper | taper(expr) expr must be an expression that evaluates to a mesh. The taper expression calculates cell taper, which is the maximum ratio of lengths derived from opposite edges. Taper is only calculated for hex and quad cells. Example: taper(MESH)
tensor_maximum_shear | Maximum tensor shear | tensor_maximum_shear(expr) expr can be a database variable, constant, or other 3x3 tensor expression. The result is a scalar expression. Example: tensor_maximum_shear(tensor)
trace | Trace of tensor | trace(expr) Expr can be an expression of database variables, constants, or other tensor expressions. The trace expression calculates the trace of a 3x3 tensor, which is the sum of the diagonal components. The result is a scalar expression. Example: trace_times_3 = trace(tensor) * 3.0
var_skew | Apply skew scaling | var_skew(expr 1, expr 2) Both expr1 and expr2 must evaluate to scalar expressions. More commonly, expr2 is a floating point constant indicating the skew factor to be used in the calculation. The var_skew expression applies skew scaling, as performed in the Pseudocolor plot, to the input data. Skew scaling can be used to highlight either small values or large values, depending on the skew factor that you provide. Expression: var_skew(density, 10.)
volume | Cell volume | volume(expr) expr must be an expression that evaluates to a 3D mesh or database variable. The volume expression calculates the volume of each cell in the mesh and creates a cell-centered scalar expression containing those values. Volumes of 2D meshes are zero. Example: volume(ucdmesh)
warpage | Cell warpage | warpage(expr) expr must be an expression that evaluates to a mesh. The warpage expression calculates how much quad cells deviate from a plane. Warpage is only calculated for quad cells. Example: warpage(quadmesh)
zoneid | Zone number | zoneid(expr) expr can be any expression involving a single mesh. The zoneid expression creates a zone-centered scalar field for the mesh used by the input expression. The zoneid expression is primarily used to debug new VisIt components such as plot plugins or database reader plugins. Example: zoneid(density)

Figure 5