Results Manipulation

Overview

The State class supports the management of solution results data for scalar, vector, six dof vector (translations and rotations), tensor (symmetric tensor) and general tensor fields defined over a solution domain. The results data may be located at nodes, elements, element nodes, element faces, element edges, element face nodes and element edge nodes. The additional, non element or node related locations, are particle and mode. For element and element node results, data may also be present for several “sections” at each element location. Sections most often represent stress results for several layers in a composite shell element or points throughout a beam cross section. The State class contains functions for mapping results quantities between node, element and element node locations. For example, solution results based at element centroids may be mapped to a state in which the results quantities are represented at the nodes. In addition, the State class provides a set of derived quantities for vector and tensor fields which may be automatically calculated, such as vector magnitude for tensor principal values. These derived quantities, such as vector magnitude for tensor principal values, are generally based on the invariants of the vector or tensor. The functions associated with a State object are the following.

Definition and options
- define() - Define parent and child entities
- inquire() - Inquire parent and child entities
- setPrecision() - Specify precision of state data
- getPrecision() - Query precision of state data
- setIntegerParameter() - Set integer parameters
- setComplexMode() - Set mode for complex data
- getComplexMode() - Get mode for complex data
- isComplex() - Query for complex data existence
- setEngineeringStrainFlag() - Set engineering strain flag
- getEngineeringStrainFlag() - Get engineering strain flag
- setMagnitudePhaseFlag() - Set magnitude phase flag
- getMagnitudePhaseFlag() - Get magnitude phase flag
Internal objects
- setMeshInterface() - Set pointers to a MeshInterface object
- getMeshInterface() - Get pointers to a MeshInterface object
- setLocalCoordinateSystemIds() - Set pointers to a IdTranslator object
- getLocalCoordinateSystemIds() - Get pointers to a IdTranslator object
- setLocalCoordinateSystemDirectionCosines() - Set pointers to a State object
- getLocalCoordinateSystemDirectionCosines() - Get pointers to a State object
- setRotationAngleVectors() - Set pointers to a State object
- getRotationAngleVectors() - Get pointers to a State object
- setCoordinateSystems() - Set pointers to a HashTable object of CoordinateSystem
- getCoordinateSystems() - Get pointers to a HashTable object of CoordinateSystem
- setElementData() - Set pointers to a HashTable object of ElementData
- getElementData() - Get pointers to a HashTable object of ElementData
Section
- setSection() - Set section number
- getSection() - Get current section number
- setSectionLayerPositionType() - Set section layer position type
- getSectionLayerPositionType() - Get section layer position type
- setLayerInformation() - Set section layer number and position
- getLayerInformation() - Get section layer number and position
- setSectionCount() - Set number of results data sections
- getSectionCount() - Get number of results data sections
- isSectionDefined() - Check if any sections defined
Derived quantity
- getDerivedQuantityComponentCount() - Get number of data components
- setDerivedQuantity() - Set derived quantity type
- getDerivedQuantity() - Get derived quantity type
- getPrimitiveDerivedQuantity() - Get data type of derived quantity
Coordinate system
- setCoordinateSystem() - Set coordinate system state
- getCoordinateSystem() - Get coordinate system state
- getCoordinateSystemIdAtEntity() - Get coordinate system identifier used in system state for an entity
- setCoordinateSystemEntityType() - Set coordinate system entity type
- getCoordinateSystemEntityType() - Get coordinate system entity type
- transformToCoordinateSystem() - Perform coordinate system transformations (parallel)
- getLocalDirectionCosineMatrices() - Get local direction cosine matrix
Set and query results
- clear() - Clear all results data
- clearDataAtEntity() - Clear results data for a single entity
- getDefinedDataCount() - Get overall number of results data
- getData() - Get results data at a set of entities
- getDataAtElement() - Get results data at element
- setDataAtElementEntity() - Set element face or edge results data
- getDataAtElementEntity() - Get results data at element entities
- getDataAtElementNaturalCoordinates() - Get results data at given natural coordinates
- getDataCountAtEntity() - Get number of results values and locations
- setDataAtEntity() - Set results data
- getDataAtEntities() - Get results data at entities
- getMaxDataCount() - Get max number of results values and locations
- setElementEntities() - Set results data element faces or edges
- getElementEntities() - Get results data element faces or edges
- getStatus() - Get results data status
- getStatusAtElementEntity() - Get element face or edge results data status
- getExtent() - Minimum and maximum values (parallel)
- getExtentWithLocation() - Minimum and maximum values and locations
- getExtentWithLocationAndSection() - Minimum and maximum values,locations,sections
Manipulate results
- convertComplexData() - Convert complex data
- convertStrainData() - Convert strain data
- deformState() - Create deformed node vector of coordinates
- derivative() - Perform differential operations on a state
- map() - Map results data to another location
- mapToElementNode() - Map results data to element node location
- processMidSideNodes() - Process results data at midside nodes
- operateBinary() - Operate on a state as a function of two states
- operateUnary() - Operate on a state as a function of one state
- computeSum() - Sum results data
Extract entity sets
- setGroupParameter() - Set group derivation parameters
- generateNodeGroup() - Derive sets of nodes
- generateElementGroup() - Derive sets of elements
- generateSortedEntities() - Sort entities into an IdTranslator object
General functions
- getErrorCode() - Return the current error code
- demonstrate() - Create “demo” node vector displacement results
- copy() - Copy a State

Once a State is instanced, the user may specify the precision used to maintain the state data using setPrecision(). By default, state data are held in single precision.

Define parent and child entity types and parent size using define(). The function is also used to specify the data type (scalar, vector, etc.) of the solution results data to be maintained by the State object. Use setDataAtEntity() to enter solution results into a State object at specified entity indices. If results data is not specified at a specific entity index it is assumed to be zero. Use clear() to clear (set to zero) all results data.

Complex valued element data may be specified. The real and imaginary parts of a complex value may be specified one at a time or together depending upon the value of the complex mode of State. The user sets the complex mode using setComplexMode(). See section Complex Numbers for a description of the general usage of complex valued data.

Complex data in State may be held as real and imaginary components or magnitude phase components. By default, complex data is assumed to be in real and imaginary form. If complex data has been entered in magnitude and phase form, use the function setMagnitudePhaseFlag() to flag this fact. The function convertComplexData() can be used to convert complex data from real/imaginary to/from magnitude/phase. The function setMagnitudePhaseFlag() will be called appropriately internally to flag the current form of complex data. Note that the units of the phase angles are degrees.

Results data is maintained at nodes, element centroids or element nodes by a state object. The number of data locations per entity for node and element states is one, for element node states, the number of data locations is the number of nodes in an element. Element and element node states may also carry data for any number of sections at each data location. These sections usually represent layers in a composite shell element or points throughout a beam cross section. If data is to be represented at sections, then the number of sections for each element must be defined using setSectionCount() before data may be set using setDataAtEntity(). Use getSectionCount() to query the number of sections at an element. By default the number of sections is 1. The layer position type of the sections at an element may be set as an option using setSectionLayerPositionType(). The layer position type specifies more detail concerning the position of a section within a layer, i.e. top, middle, bottom, etc. More detailed information about layer number and layer position of each section can be set using the function setLayerInformation(). The function getLayerInformation() can retrieve the layer numbers and positions. If explicit layer numbers and positions are not defined for each section index, then the layer numbers are assumed to start from 1 and increment sequentially with a layer number multiplicity dependent upon the layer position type. If there are several sections of data at an element, use setSection() to control whether all sections or only a selected section of data are returned using getData(). By default section 1 is set.

For element face, element face node, element edge and element edge node locations, the element faces or edges for which data will be defined must be specified using function setElementEntities() before the actual data is set. Use the function setDataAtElementEntity() to set data at a specific element face or element edge.

By convention, vector data is assumed to be ordered by (x,y,z) components, six dof vector data by (tx,ty,tz,rx,ry,rz) components, symmetric tensor data by (xx,yy,zz,xy,yz,zx) components, and general tensor data by (xx,xy,xz,yx,yy,yz,zx,zy,zz) components, Use getData() to query for results data for some entity subset. A State object will automatically return a derived quantity when getData() is called by setting a derived quantity with setDerivedQuantity().

The function getDataAtElement() is a convenient function to use for returning data at an element regardless of the parent and child entity types of the State object. This function is sensitive to the mapping options which are used to map element node data to elements.

The function getDataAtElementEntity() is a convenient function to use for returning data for all element nodes, element face nodes or element edge nodes regardless of the parent and child entity types of the State object. Use getDataAtElementNaturalCoordinates() to retrieve interpolated values at a given natural coordinates location within an element. The function getStatus() may be used to determine if the data for a given set of entities has been specified using setDataAtEntity(). The function getStatusAtElementEntity() may be used for element face and element edge states to determine data defined at a specific element face or element edge.

Vectoral derived quantities include only the vector magnitude.

VECTOR_MAGNITUDE, Magnitude
```
v(mag) = sqrt(vx**2 + vy**2 + vz**2)
```

Tensoral derived quantities include the following. The quantities tmax,tmid and tmin are the maximum, middle and minimum principal values.

TENSOR_MEAN, Mean
```
t(mean) = 1/3*(txx+tyy+tzz);
```

TENSOR_VONMISES_STRESS, Von Mises

t(vonmises) = sqrt(1/2*((txx-tyy)**2 + (tyy-tzz)**2 + (tzz-txx)**2) +
                   3*(txy**2 + tyz**2 + tzx**2))

TENSOR_VONMISES_STRAIN, Von Mises Strain

t(vonmises) = 2./3.*sqrt(1/2*((txx-tyy)**2 + (tyy-tzz)**2 + (tzz-txx)**2) +
                         3*(txy**2 + tyz**2 + tzx**2))

TENSOR_OCTAHEDRAL, Octahedral

t(octahedral) = sqrt(1/9*((txx-tyy)**2 + (tyy-tzz)**2 + (tzz-txx)**2) +
                     2/3*(txy**2 + tyz**2 + tzx**2))

TENSOR_MAXSHEAR, Max Shear
```
t(max shear) = 1/2*(tmax - tmin)
```
TENSOR_EQUAL_DIRECT, Equal direct stress in Max Shear directions
```
t(equ direct) = 1/2*(tmax + tmin)
```

TENSOR_INTENSITY, Intensity

t(intensity) = MAX((tmax-tmin),(tmid-tmin),(tmax-tmid))

If Von Mises strain is requested, it will be computed as 2/3 of the value of Von Mises stress. This is a special case (Nu=0.5) of a more general formula in which Von Mises strain is 1./(1.+Nu) of the Von Mises stress where Nu is an effective Poisson’s ratio.

If tensor principal values are requested, the values are sorted by numeric value, not absolute value.

Note that in the direction of max shear stress, two of the direct stresses are equal and may be derived using TENSOR_EQUAL_DIRECT, the other stress is equal to the middle principal value and may be derived using TENSOR_MID_PRINCIPAL. The maximum shear is derived using TENSOR_MAXSHEAR, the other two shear stresses are zero. The maximum shear angle, TENSOR_SHEAR_ANGLE, is the angle formed by the direction of maximum shear with the x axis in degrees.

Note that the tensor intensity definition is taken directly from ANSYS documentation. Since (tmax-tmin) is always the maximum, the other terms are unnecessary. It is always equal to twice the maximum shear.

A practical note should be made concerning representing shear strains as a tensor-valued quantity with the State class. In many commercial finite element programs shear strain is reported as engineering strain rather than tensor strain. The shear strain components of engineering strain are twice the value of the corresponding components of tensor strain. The user may enable the State class to treat the engineering strain variant of a tensor by calling setEngineeringStrainFlag(). This is required so that all invariant calculations, transformations, etc. are properly performed. Note that the Max Shear derived value for engineering strain will be returned as twice the tensoral value. The function convertStrainData() can be used to convert strain data from tensor to/from engineering strain. The function setEngineeringStrainFlag() will be called appropriately internally to flag the current form of strain data.

The getExtent() function returns the minimum and maximum results data values over a specified subset of the solution domain. The domain subset is defined by an input Group object.

Results data is maintained at nodes, element centroids or element nodes by a state object. It is often useful to be able to interpolate or extrapolate results data from one location to another. The map() function is designed to perform this operation. The mapping of data from elements or element nodes to nodes may be performed using a topologically or geometrically based weighting. A topological weighting assigns an equal weight to each element contribution connected to a node. A geometric weighting assigns a weight proportional to the reciprocal of the volume of the element (area for 2D elements, length for 1D elements and unity for 0D elements).

A specific function, mapToElementNode(), is available for averaging and mapping element centroid or element node data to element nodes in which averaging is performed only within user specified regions. For example, it is common for element stress results to be output at element nodes in which the stresses have been computed using local element methods. This results in general stress discontinuities between all elements. A typical post processing function is to average the element nodal stresses at nodes within regions of homogeneous elements. This will result in removing the element stress discontinuities between elements in the same region but preserving the discontinuity at the boundaries between regions. The resulting data location must be element nodal to represent the region discontinuity.

The function, processMidSideNodes(), is available for specialized processing of data at element midside nodes as a function of the element corner nodes. Options include linear interpolation of the data at midside nodes and clamping the data at midside nodes. Only edge midside nodes are affected, midface and midbody nodes are not processed.

Local Coordinate Systems

The State class may also be used to maintain local coordinate system information for vector, sixdof vector, tensor and general tensor states and perform transformations of the state data between the local system and the global coordinate system. Use transformToCoordinateSystem() to transform state data between the local and global systems. The coordinate system state (local or global) of the data is specified by setCoordinateSystem(). The current coordinate system state of the data may be queried using getCoordinateSystem(). There are two basic types of local coordinate systems: 1) local systems in the undeformed coordinates and 2) local systems in deformed coordinates. The function getLocalDirectionCosineMatrices() may be used to obtain the direction cosine matrix of the current coordinate system of any node and/or element.

The local undeformed coordinate system information may be maintained by any combination of user defined local coordinate systems represented by a HashTable of CoordinateSystem objects and element local coordinates systems which are computed using a specified algorithm, usually as a function of element geometry. The element geometry consists of the element node coordinates and an optional HashTable of ElementData objects which contain vectors to orient local coordinate systems.

The way in which local undeformed coordinate system information is maintained at each node or element is specified by a set of integer flags. By default, these coordinate system identifiers are defined by the node COORDINATE_SYSTEM_ID or element COORDINATE_SYSTEM_ID association. However an option is provided to specify integer flags contained in an IdTranslator attribute object. Use the function setLocalCoordinateSystemIds() to register the IdTranslator object. Normally element node states assume that the coordinate system identifiers are associated with elements, however the user can specify that the coordinate system identifiers be associated with the element nodes. Set this option using setCoordinateSystemEntityType(). Use the function setCoordinateSystems() to register the HashTable of CoordinateSystem objects and setElementData() for HashTable of ElementData objects.

The local undeformed coordinate system flags are assigned as follows: See section Element Coordinate Systems for a description of element coordinate systems.

=0	Global coordinate system
>0	Identifier of local coordinate system defined by CoordinateSystem object. All CoordinateSystem objects referenced in this way must be installed in a HashTable attribute object.
<0	Identifier of element geometry dependent algorithm. The algorithm may require the geometry information contained in an ElementData object. All ElementData objects referenced in this way must be installed in a HashTable attribute object.

The local deformed coordinate system information is maintained as an associated State object containing the rotation angle vectors which define the coordinate systems of each entity. Use the function setRotationAngleVectors() to register the State object of rotation angle vectors.

Parallel Functions

The following functions are optimized to take full advantage of OpenMP parallelization:

getExtent()
transformToCoordinateSystem()

MeshInterface member

A State class uses a MeshInterface member to access finite element data from the host application. This member is required for any operations which relate elements to nodes or vice versa. For example, storing element node results in a State object or performing any mapping operation requires a MeshInterface member to be set.

The State class calls the following MeshInterface functions set in the MeshInterface member.

A IdTranslator member is required for specifying local coordinate system flags for each entity, node or element, contained in the State object. Depending upon how the coordinate system information is maintained, either a HashTable attribute of CoordinateSystem class and/or a State attribute of direction cosine matrices may be required.

Class Members Descriptions

The currently available State enumerations and functions are described in detail in this section.

class State

Results Data management.

Public Types

enum class Operation

Operation type.

Values:

enumerator EQUAL: Operation =.

enumerator PLUS_EQUAL: Operation +=.

enumerator MINUS_EQUAL: Operation -=.

enumerator MULTIPLY_EQUAL: Operation *=.

enumerator DIVIDE_EQUAL: Operation /=.

enum class System

System state type.

Values:

enumerator GLOBAL: Global.

enumerator LOCAL_UNDEFORMED: Local undeformed.

enumerator LOCAL_DEFORMED: Local deformed.

enumerator MATERIAL: Material system.

enum class UnaryFunction

Unary function type.

Values:

enumerator IDENTITY: Identity function.

enumerator SIN: Sine function.

enumerator COS: Cosine function.

enumerator TAN: Tangent function.

enumerator ASIN: Arcsine function.

enumerator ACOS: Arccosine function.

enumerator ATAN: Arctangent function.

enumerator SQRT: Square root function.

enumerator LOG: Natural logarithm function.

enumerator EXP: Exponential function.

enumerator ABS: Absolute value function.

enumerator RECIPROCAL: Reciprocal function.

enumerator UNITY: Value of 1.

enum class BinaryFunction

Binary function type.

Values:

enumerator MIN: Minimum function.

enumerator MAX: Maximum function.

enumerator AVERAGE: Average function.

enumerator CROSS: Vector cross product function.

enumerator DOT: Vector dot product function.

enumerator SUM: Sum function.

enum class DifferentialOperation

Differential operation type.

Values:

enumerator GRADIENT: Gradient function.

enumerator GRADIENT_NORMALIZED: Normalized Gradient function.

enumerator DIVERGENCE: Divergence function.

enumerator CURL: Curl function.

enumerator STRAIN: Infinitesimal strain function.

enumerator VECTOR_GRADIENT: Vector gradient function.

enum class GroupOperation

Group operation type.

Values:

enumerator EXTENT: Elements lying within an interval.

enumerator DEFINED: Elements with defined data.

enumerator NONZERO: Elements with non zero value.

enumerator OUTBOUND: Elements lying outside an interval.

enumerator LOCAL_MIN: Elements with local minimum.

enumerator LOCAL_MAX: Elements with local maximum.

enumerator LOCAL_MINMAX: Elements with local min or max.

enum class IntegerParameter

Integer parameter types.

Values:

enumerator MAPPING_ELEMENT: Select element mapping type.

enumerator MAPPING_NODE: Select node mapping type.

enumerator MAPPING_DEFINED: Enable mapping defined entities only.

enumerator MAPPING_NONZERO: Enable mapping nonzero contributions.

enumerator MIDSIDE: Select midside node processing.

enumerator SORT_DESCENDING: Enable high to low sort.

enumerator SORT_ABSOLUTE_VALUE: Enable absolute value sort.

enumerator SORT_ELEMENT_AVERAGE: Enable element-average sorting.

enumerator EXTENT_IGNORE_ZERO: Ignore zero-valued entities in extent.

enumerator LIST_WIDTH: Listing field width.

enum class ElementMappingParameter

Element mapping parameter types.

Values:

enumerator AVERAGE: Average to element.

enumerator MINIMUM: Minimum to element.

enumerator MAXIMUM: Maximum to element.

enumerator ABSOLUTE_MINIMUM: Absolute minimum to element.

enumerator ABSOLUTE_MAXIMUM: Absolute maximum to element.

enumerator CENTROIDAL: Centroidal value to element.

enum class NodeMappingParameter

Node mapping parameter types.

Values:

enumerator AVERAGE: Average to node.

enumerator GEOMETRY: Geometry weighted average to node.

enumerator MINIMUM: Minimum to node.

enumerator MAXIMUM: Maximum to node.

enumerator ABSOLUTE_MINIMUM: Absolute minimum to node.

enumerator ABSOLUTE_MAXIMUM: Absolute maximum to node.

enumerator DIFF_TO_NODE: Difference to node.

enum class MidsideParameter

Midside node processing parameter types.

Values:

enumerator MIDSIDE_AVERAGE: Average midside node values.

enumerator MIDSIDE_CLAMP: Clamp midside node values.

enum class DerivedType

Derived quantity types.

Values:

enumerator VECTOR_X: Vector x component.

enumerator VECTOR_Y: Vector y component.

enumerator VECTOR_Z: Vector z component.

enumerator VECTOR_MAGNITUDE: Vector magnitude.

enumerator VECTOR: Vector.

enumerator SIX_DOF: Six dof vector.

enumerator SIX_DOF_TX: Six dof x translational component.

enumerator SIX_DOF_TY: Six dof y translational component.

enumerator SIX_DOF_TZ: Six dof z translational component.

enumerator SIX_DOF_RX: Six dof x rotational component.

enumerator SIX_DOF_RY: Six dof y rotational component.

enumerator SIX_DOF_RZ: Six dof z rotational component.

enumerator SIX_DOF_TRANSLATIONAL_MAGNITUDE: Six dof translation magnitude.

enumerator SIX_DOF_ROTATIONAL_MAGNITUDE: Six dof rotation magnitude.

enumerator SIX_DOF_TRANSLATION_VECTOR: Six dof translation vector.

enumerator SIX_DOF_ROTATION_VECTOR: Six dof rotation vector.

enumerator TENSOR_XX: Tensor xx component.

enumerator TENSOR_YY: Tensor yy component.

enumerator TENSOR_ZZ: Tensor zz component.

enumerator TENSOR_XY: Tensor xy component.

enumerator TENSOR_YZ: Tensor yz component.

enumerator TENSOR_ZX: Tensor zx component.

enumerator TENSOR_MEAN: Tensor mean.

enumerator TENSOR_VONMISES_STRESS: Tensor Von Mises stress.

enumerator TENSOR_VONMISES_STRAIN: Tensor Von Mises strain.

enumerator TENSOR_OCTAHEDRAL: Tensor octahedral shear.

enumerator TENSOR_DETERMINANT: Tensor determinant.

enumerator TENSOR_INTENSITY: Tensor intensity.

enumerator TENSOR_SHEAR_ANGLE: Tensor max shear angle in degrees.

enumerator TENSOR_MAXSHEAR: Tensor max shear.

enumerator TENSOR_EQUAL_DIRECT: Tensor equal direct at max shear.

enumerator TENSOR_MIN_PRINCIPAL: Tensor minimum principal value.

enumerator TENSOR_MID_PRINCIPAL: Tensor middle principal value.

enumerator TENSOR_MAX_PRINCIPAL: Tensor maximum principal value.

enumerator TENSOR_MIN_PRINCIPAL_DEVIATORIC: Tensor minimum principal deviatoric value.

enumerator TENSOR_MID_PRINCIPAL_DEVIATORIC: Tensor middle principal deviatoric value.

enumerator TENSOR_MAX_PRINCIPAL_DEVIATORIC: Tensor maximum principal deviatoric value.

enumerator TENSOR_PRINCIPAL_VALUES: Tensor principal values.

enumerator TENSOR_PRINCIPAL_DIRECTIONS: Tensor principal directions.

enumerator TENSOR: Tensor.

enumerator GENERALTENSOR: General tensor.

enumerator TENSOR_GENERAL_XX: General tensor xx component.

enumerator TENSOR_GENERAL_XY: General tensor xy component.

enumerator TENSOR_GENERAL_XZ: General tensor xz component.

enumerator TENSOR_GENERAL_YX: General tensor yx component.

enumerator TENSOR_GENERAL_YY: General tensor yy component.

enumerator TENSOR_GENERAL_YZ: General tensor yz component.

enumerator TENSOR_GENERAL_ZX: General tensor zx component.

enumerator TENSOR_GENERAL_ZY: General tensor zy component.

enumerator TENSOR_GENERAL_ZZ: General tensor zz component.

enumerator TENSOR_GENERAL_SYMMETRIZED: General tensor symmetrized tensor.

enumerator TENSOR_GENERAL_FIRST_ROW: General tensor first row vector.

enumerator TENSOR_GENERAL_SECOND_ROW: General tensor second row vector.

enumerator TENSOR_GENERAL_THIRD_ROW: General tensor third row vector.

enumerator SHELL_NXX: Shell Nxx component.

enumerator SHELL_NYY: Shell Nyy component.

enumerator SHELL_NXY: Shell Nxy component.

enumerator SHELL_MXX: Shell Mxx component.

enumerator SHELL_MYY: Shell Myy component.

enumerator SHELL_MXY: Shell Mxy component.

enumerator SHELL_QXZ: Shell Qxz component.

enumerator SHELL_QYZ: Shell Qyz component.

enumerator BEAM_NXX: Beam Nxx component.

enumerator BEAM_MYY: Beam Myy component.

enumerator BEAM_MZZ: Beam Mzz component.

enumerator BEAM_T: Beam Torque component.

enumerator BEAM_QXY: Beam Qxy component.

enumerator BEAM_QZX: Beam Qzx component.

enumerator BEAM_TB: Beam Bimoment component.

enumerator SPRINGDASHPOT_F: SpringDashpot Force component.

enumerator SPRINGDASHPOT_FX: SpringDashpot Force X component.

enumerator SPRINGDASHPOT_FY: SpringDashpot Force Y component.

enumerator SPRINGDASHPOT_FZ: SpringDashpot Force Z component.

enumerator SPRINGDASHPOT_MX: SpringDashpot Moment X component.

enumerator SPRINGDASHPOT_MY: SpringDashpot Moment Y component.

enumerator SPRINGDASHPOT_MZ: SpringDashpot Moment Z component.

enumerator SCALAR: Scalar.

enumerator SCALARS_0: Zeroth scalar.

enumerator SCALARS_1: First scalar.

enumerator SCALARS_2: Second scalar.

enumerator SCALARS_3: Third scalar.

enumerator SCALARS_4: Fourth scalar.

enumerator SCALARS_5: Fifth scalar.

enumerator SCALARS_6: Sixth scalar.

enumerator SCALARS_7: Seventh scalar.

enumerator SCALARS_8: Eighth scalar.

enumerator SCALARS_9: Ninth scalar.

enumerator SCALARS_10: Tenth scalar.

enumerator SCALARS_11: Eleventh scalar.

enumerator SCALARS_12: Twelfth scalar.

enum class DemonstrationType

Demonstration types.

Values:

enumerator BEAM: Create beam bending displacements.

enumerator PLATE: Create plate bending displacements.

Public Functions

ErrorCode getErrorCode()

Return the current ErrorCode of the State object.

Returns:	`ErrorCode` - The current error code, or `NONE` if no error.

Status setPrecision(Precision precisionType)

Specify the precision used to maintain State data. All previously defined data is cleared by this function. The function should be called before define() . By default, State data are held in single precision.

See Also setCoordinateSystem()

Parameters:	system – [out] `System`
Returns:	Status

Status setCoordinateSystemEntityType(EntityType type)

Specify the coordinate system entity type of the State object. By default the coordinate system entity type is the same as the parent entity type. Note that this is needed in the case of element node State in which the nodal data is in a node based coordinate system.

Errors

OPERATION is generated if a type of NODE is specified for an element State or a type of ELEMENT is specified for a node state.

Parameters:	type – `EntityType` `ELEMENT` `NODE`
Returns:	Status

Status getCoordinateSystemEntityType(EntityType *type)

Get the coordinate system entity type of the State object.

Parameters:	type – [out] `EntityType`
Returns:	Status

Status transformToCoordinateSystem(System system, Group *group)

Transform vector, six dof vector, tensor or general tensor data from the current coordinate system State to global coordinates or vice versa. The coordinate system State of the data is set using setCoordinateSystem() . The current coordinate system State may be queried using getCoordinateSystem() . If the current coordinate system State is the same as system, this function returns immediately. If the State data type is scalar this function returns immediately.

Errors

VALUE is generated if group is not the same entity type as the state.
NULLOBJECT is generated if the MeshInterface, IdTranslator, HashTable or State attribute objects have not been set.
OPERATION is generated if not a node or element state.
OPERATION is generated if an element integration point state does not involve a LOCAL_DEFORMED system.

Parameters:	system – `System` to transform to ( `GLOBAL` , `LOCAL_UNDEFORMED` , or `LOCAL_DEFORMED` ). group – Pointer to Group object of entities to transform. If NULL, then all entities are assumed.
Returns:	Status

Status convertStrainData(StrainType type)

Convert strain data from tensor to/from engineering form. If strainType is not TENSOR or ENGINEERING or the type matches the current internal type, this function returns. The function setEngineeringStrainFlag() is called internally to set the current State of the strain data after conversion.

Parameters:	type – `StrainType` type
Returns:	Status

Status convertComplexData(ComplexMode complexType)

Convert complex data from real/imaginary to/from magnitude/phase form. If the data is not complex, complexType is not REAL_IMAGINARY or MAGNITUDE_PHASE or the complexType matches the current internal type, this function returns. The function setMagnitudePhaseFlag() is called internally to set the current State of the complex data after conversion.

Parameters:	complexType – `ComplexMode` ( `REAL_IMAGINARY` or `MAGNITUDE_PHASE` )
Returns:	Status

Status demonstrate(DemonstrationType operation, float factor, Group *group)

Create “demo” node vector displacement results. Set the contents of the State object to a vector of node displacements which resemble either beam or plate bending. The maximum displacement magnitude is factor times one half of the maximum model extent along the global axes. The undeformed coordinates are accessed from the MeshInterface attribute object. Set the MeshInterface attribute object using setMeshInterface() .

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State is not a node vector state.
NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	operation – Operation `DemonstrationType` specified to create displacement results factor – Floating point factor group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status deformState(float factor, State *displacements, Group *group)

Create deformed node vector of coordinates. Set the contents of the State object to the sum of the undeformed coordinates plus some factor, factor, times the displacements contained in displacements. The undeformed coordinates are accessed from the MeshInterface attribute object. Set the MeshInterface attribute object using setMeshInterface() . The states must be node states. The State object must be a vector state, the displacements object must be a node vector or node sixdof state. This routine implements the following equation,

State = undeformed_coordinates + factor * displacements

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State is not a node vector state or displacements is not a node vector or node sixdof state.
NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	factor – Floating point coefficient displacements – Pointer to State object of node displacements group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status getData(int entityCount, int indices[], float data[])

Get results data, data, for a set of entities, indices. The results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() . The results data returned in array data is ordered as results data for entity indices[0] followed by results data for indices[1],…,indices[entityCount-1]. If the current section is greater than the number of sections for a particular entity, then zeros are returned for that section.

Use setDataAtEntity() to set results data.

Errors: VALUE is generated if an improper entityCount or indices are specified.

Parameters:	entityCount – Number of entities to return results indices – Array of entity indices data – [out] Array of returned results data
Returns:	Status

Status getData(int entityCount, int indices[], double data[])

Get results data, data, for a set of entities, indices. The results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() . The results data returned in array data is ordered as results data for entity indices[0] followed by results data for indices[1],…,indices[entityCount-1]. If the current section is greater than the number of sections for a particular entity, then zeros are returned for that section.

Use setDataAtEntity() to set results data.

Errors: VALUE is generated if an improper entityCount or indices are specified.

Parameters:	entityCount – Number of entities to return results indices – Array of entity indices data – [out] Array of returned results data
Returns:	Status

Status getDataAtElement(int elementId, float data[])

Get results data, data, for element elementId. The results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() . The results data is also sensitive to the MAPPING_ELEMENT mapping options which are set using setIntegerParameter() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	elementId – Element index data – [out] Array of returned results data
Returns:	Status

Status getDataAtElement(int elementId, double data[])

Get results data, data, for element elementId. The results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() . The results data is also sensitive to the MAPPING_ELEMENT mapping options which are set using setIntegerParameter() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	elementId – Element index data – [out] Array of returned results data
Returns:	Status

Status getDataAtElementEntity(EntityType type, int elementId, int elementEntityNumber, float data[])

Get results data, data, for a set of nodes connected to element elementId. The nodes may include all the element nodes or only those nodes connected to a specified, elementEntityNumber, element face or edge. If type is set to ELEMENT then the argument, elementEntityNumber, is ignored. The results data is subject to the current derived quantity specified by setDerivedQuantity() . If the State is element or element node, the results data is subject to the current section set by setSection() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	type – `EntityType` `ELEMENT` `FACE` `EDGE` elementId – Element index elementEntityNumber – Element face or edge number data – [out] Array of returned results data
Returns:	Status

Status getDataAtElementEntity(EntityType type, int elementId, int elementEntityNumber, double data[])

Get results data, data, for a set of nodes connected to element elementId. The nodes may include all the element nodes or only those nodes connected to a specified, elementEntityNumber, element face or edge. If type is set to ELEMENT then the argument, elementEntityNumber, is ignored. The results data is subject to the current derived quantity specified by setDerivedQuantity() . If the State is element or element node, the results data is subject to the current section set by setSection() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	type – `EntityType` `ELEMENT` `FACE` `EDGE` elementId – Element index elementEntityNumber – Element face or edge number data – [out] Array of returned results data
Returns:	Status

Status getDataAtElementNaturalCoordinates(int elementId, float naturalCoordinates[], float data[])

Get results data, data, for a natural coordinate value naturalCoordinates at element elementId. Like other retrieval methods, the results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	elementId – Element index naturalCoordinates – Element natural coordinates data – [out] Array of returned results data
Returns:	Status

Status getDataAtElementNaturalCoordinates(int elementId, double naturalCoordinates[], double data[])

Get results data, data, for a natural coordinate value naturalCoordinates at element elementId. Like other retrieval methods, the results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() .

Errors: NULLOBJECT is generated if a MeshInterface object has not been set.

Parameters:	elementId – Element index naturalCoordinates – Element natural coordinates data – [out] Array of returned results data
Returns:	Status

Status getDataAtEntities(int entityCount, int indices[], double data[])

Get results data, data, for a set of entities, indices. The results data is subject to the current derived quantity specified by setDerivedQuantity() and the current section set by setSection() .

Use setDataAtEntity() to set results data.

Errors: VALUE is generated if an improper entityCount or indices are specified.

Parameters:	entityCount – Number of entities to return results indices – Array of entity indices data – [out] Array of returned results data
Returns:	Status

Status getDataCountAtEntity(int index, int *totalDataCount, int *locationCount, int *sectionCount)

Return the number of data values, locations and sections returned by subsequent queries of the state. These query functions include getData() and getExtent() . The number of sections, sectionCount, depends upon the number of sections defined for the element and the current returned section option specified by setSection() . The number of locations, locationCount, will be 1 for node and element sections and equal to the number of element nodes for element node sections. The total number of data values, totalDataCount, will be the product of the number of components in the current derived quantity with the number of locations and the number of sections. Note that if the data is complex and the complex mode is REAL_IMAGINARY the number of data values, totalDataCount, is multiplied by 2.

Errors: VALUE is generated if an improper index is specified.

Parameters:	index – Entity index to query totalDataCount – [out] Total number of data values locationCount – [out] Number of data locations sectionCount – [out] Number of data sections
Returns:	Status

Status getMaxDataCount(int *totalDataCount, int *locationCount, int *sectionCount)

Return the maximum number of data values, locations and sections. The totalDataCount value can be used to allocate memory which is guaranteed to hold the data returned by any call to getData() . The sectionCount value can be used to determine if any section data has been defined on any element.

Parameters:	totalDataCount – [out] Maximum number of data values locationCount – [out] Maximum number of data locations sectionCount – [out] Maximum number of data sections
Returns:	Status

Status getLocalDirectionCosineMatrices(int index, float cosineMatricesArray[][3][3])

Get direction cosine matrices, cosineMatricesArray, for an entity, index. The direction cosine matrices are the local system of the node, element or element nodes used in the transformToCoordinateSystem() function.

Errors: NULLOBJECT is generated if the MeshInterface or IdTranslator attribute objects have not been set.

Parameters:	index – Entity index cosineMatricesArray – [out] Array of returned direction cosine matrices
Returns:	Status

Status getExtent(Group *group, float extent[])

Compute minimum and maximum values of results data for a set of entities specified by an optional input group. The extent array contains the minimum results data values followed by the maximum results data values. The minimum and maximum are calculated for the current derived quantity. For example for a vector State a total of 6 values (minimum x,y,z followed by maximum x,y,z) will be returned in extent. Any entities for which data has not been defined are skipped.

Errors: VALUE is generated if group parent entity size and type does not match the parent entity size and type of the State object.

Parameters:	group – Pointer to Group object. If NULL, then all entities are assumed. extent – [out] Minimum and maximum values of results data
Returns:	Status

Status getExtentWithLocation(Group *group, float extent[], int indices[], int elementEntityNumbers[])

Compute minimum and maximum values of results data for a set of entities specified by an optional input group and return the corresponding locations at which the extremes occur. The extent array contains the minimum results data values followed by the maximum results data values. The minimum and maximum are calculated for the current derived quantity. The indices array contains the node or element indices corresponding to the extreme values in extent. The elementEntityNumbers array is filled only if the State is an element node state. It contains the element connectivity index of the element node. Any entities for which data has not been defined are skipped.

Errors: VALUE is generated if group parent entity size and type does not match the parent entity size and type of the State object.

Parameters:	group – Pointer to Group object. If NULL, then all entities are assumed. extent – [out] Minimum and maximum values of results data indices – [out] Entity indices at which extremes occur elementEntityNumbers – [out] Element node connectivity indices
Returns:	Status

Status getExtentWithLocationAndSection(Group *group, float extent[], int indices[], int elementEntityNumbers[], int sections[])

Compute minimum and maximum values of results data for a set of entities specified by an optional input group and return the corresponding locations and sections at which the extremes occur. This function is similar to getExtentWithLocation() except that section numbers are also returned.

Errors: VALUE is generated if group parent entity size and type does not match the parent entity size and type of the State object.

Parameters:	group – Pointer to Group object. If NULL, then all entities are assumed. extent – [out] Minimum and maximum values of results data indices – [out] Entity indices at which extremes occur elementEntityNumbers – [out] Element node connectivity indices sections – [out] Section numbers
Returns:	Status

Status computeSum(Group *group, double sum[])

Sum results data, sum, for a set of entities specified by an optional input group. The sum is calculated for the current derived quantity.

Errors: VALUE is generated if group parent entity size and type does not match the parent entity size and type of the State object.

Parameters:	group – Pointer to Group object. If NULL, then all entities are assumed. sum – [out] Array of summed results data
Returns:	Status

Status map(State *source, Group *group)

Map results quantities between node, element and element node locations. This function maps results data from the entity locations of the source source object to the entity locations of the State object. The source object is unchanged by this function. The quantity mapped from the source is dependent upon the current derived quantity in source, see setDerivedQuantity() . The mapping process is subject to an optional group which determines the element entities which are to be mapped to the State object. The State and source objects must be distinct.

Note that a MeshInterface attribute object must be set in any element or element node states for any mapping operation. Set this attribute object using setMeshInterface() .

The algorithm used to map quantities to elements from nodes or element nodes may select an average quantity, geometry weighted average quantity, maximum difference quantity or minimum or maximum quantities. Use setIntegerParameter() with MAPPING_NODE to set the node mapping type. Use setIntegerParameter() with MAPPING_ELEMENT to set the element mapping type.

Errors

VALUE is generated if group parent entity type is not ELEMENT or size does not match the number of elements.
NULLOBJECT is generated if a MeshInterface attribute object has not been set.
OPERATION is generated if the parent and child entity types of the State and source objects are identical.

Parameters:	source – Pointer to source State object group – Pointer to Group object of elements. If NULL, then all elements are assumed.
Returns:	Status

Status processMidSideNodes(Group *group)

Provide specialized processing for data at the midside nodes of elements as a function of the corner nodes (edge endpoint nodes) of the element. Only edge midside nodes are affected, midface and midbody nodes are not processed. Note that a MeshInterface attribute object must be set in the object. Set this attribute object using setMeshInterface() .

Processing options include linearly interpolating the midside node data as a function of the edge endpoint node data or clamping the midside node data to the minimum and maximum of the edge endpoint node data. By default, the midside node data is linearly interpolated. Use setIntegerParameter() with MIDSIDE to control the processing option.

Errors

VALUE is generated if group parent entity type is not ELEMENT or size does not match the number of elements.
NULLOBJECT is generated if a MeshInterface attribute object has not been set.
OPERATION is generated if sections are defined.

Parameters:	group – Pointer to Group object of elements. If NULL, then all elements are assumed.
Returns:	Status

Status mapToElementNode(State *source, Group *group, IdTranslator *elementRegionNumber)

Map results data to element node locations. This function maps results data from the entity locations of the source source object to the entity locations of the State object. The source object is unchanged by this function. The quantity mapped from the source is dependent upon the current derived quantity in source, see setDerivedQuantity() . The input elementRegionNumber object must contain a region number for each element. Data is averaged at element nodes using only elements within the same region. If elementRegionNumber is NULL, then all elements are assumed to be in a single mapping region. The mapping process is subject to an optional group which determines the element entities which are to be mapped to the State object.

Note that a MeshInterface attribute object must be set in any element or element node states for any mapping operation. Set this attribute object using setMeshInterface() .

Use setIntegerParameter() with MAPPING_NODE to set the node mapping type. Use setIntegerParameter() with MAPPING_ELEMENT to set the element mapping type.

Errors

VALUE is generated if group parent entity type is not ELEMENT or size does not match the number of elements.
NULLOBJECT is generated if a MeshInterface attribute object has not been set.

Parameters:	source – Pointer to source State object group – Pointer to Group object of elements. If NULL, then all elements are assumed. elementRegionNumber – Pointer to IdTranslator object of element region numbers
Returns:	Status

Status operateUnary(Operation operation, float factor, UnaryFunction function, State *statex, Group *group)

Modify the contents of the State object as a function of a single state, statex. The function, function is performed upon the state, statex. This result is scaled by a specified constant factor, factor. The result then modifies the destination State object in some way depending upon operation. Any entities for which data has not been defined are skipped. Note that function of UNITY ignores statex.

If the State object has no prior data set, then it is initialized with the derived section configuration of statex.

This routine implements the following equation,

State operation factor*function(statex)

The State and statex objects may be the same.

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State and statex entity types are not identical or the derived data type of statex does not match the basic data type of the State object.
OPERATION is generated if the State and statex have incompatible section configurations.

Parameters:	operation – `Operation` factor – Floating point coefficient function – `UnaryFunction` statex – Pointer to State operand object group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status operateUnary(Operation operation, double factor, UnaryFunction function, State *statex, Group *group)

Modify the contents of the State object as a function of a single state, statex. The function, function is performed upon the state, statex. This result is scaled by a specified constant factor, factor. The result then modifies the destination State object in some way depending upon operation. Any entities for which data has not been defined are skipped. Note that function of UNITY ignores statex.

If the State object has no prior data set, then it is initialized with the derived section configuration of statex.

This routine implements the following equation,

State operation factor*function(statex)

The State and statex objects may be the same.

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State and statex entity types are not identical or the derived data type of statex does not match the basic data type of the State object.
OPERATION is generated if the State and statex have incompatible section configurations.

Parameters:	operation – `Operation` factor – Floating point coefficient function – `UnaryFunction` statex – Pointer to State operand object group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status operateBinary(Operation operation, float factor, BinaryFunction function, State *statex, State *statey, Group *group)

Modify the contents of the State object as a function of two states, statex and statey. The function, function is performed upon the states, statex and statey. This result is scaled by a specified constant factor, factor. The result then modifies the destination State object in some way depending upon operation. Any entities for which data has not been defined are skipped.

If the State object has no prior data set, then it is initialized with the derived section configuration of statex.

This routine implements the following equation,

State operation factor*function(statex,statey)

The State, statex and statey objects may be the same.

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State, statex and statey entity types are not identical.
OPERATION is generated for the CROSS operation if the derived data types of the State, statex and statey are not vector.
OPERATION is generated for the DOT operation if the basic data type of the State object is not scalar and the derived data types of statex and statey are not vector.
OPERATION is generated if the State, statex and statey have incompatible section configurations.

Parameters:	operation – `Operation` factor – Floating point coefficient function – `BinaryFunction` statex – Pointer to first State operand object statey – Pointer to second State operand object group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status operateBinary(Operation operation, double factor, BinaryFunction function, State *statex, State *statey, Group *group)

Modify the contents of the State object as a function of two states, statex and statey. The function, function is performed upon the states, statex and statey. This result is scaled by a specified constant factor, factor. The result then modifies the destination State object in some way depending upon operation. Any entities for which data has not been defined are skipped.

If the State object has no prior data set, then it is initialized with the derived section configuration of statex.

This routine implements the following equation,

State operation factor*function(statex,statey)

The State, statex and statey objects may be the same.

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State, statex and statey entity types are not identical.
OPERATION is generated if the State, statex and statey have incompatible section configurations.

Parameters:	operation – `Operation` factor – Floating point coefficient function – `BinaryFunction` statex – Pointer to first State operand object statey – Pointer to second State operand object group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status derivative(Operation operation, float factor, DifferentialOperation function, State *statex, Group *group)

Modify the contents of the State object as a function of a single state, statex. The function, function is performed upon the state, statex. This result is scaled by a specified constant factor, factor. The result then modifies the destination State object in some way depending upon operation. The source state, statex must be a node or element node state. The destination State object may be either an element or element node state. The data type of the State object and the derived type of statex depend upon the specified function, function as follows:

 function             State          statex
 ------------------------------------------
 CURL                 vector         vector
 DIVERGENCE           scalar         vector
 GRADIENT             vector         scalar
 GRADIENT_NORMALIZED  vector         scalar
 STRAIN               tensor         vector
 VECTOR_GRADIENT      generaltensor  vector

This routine implements the following equation,

State operation factor*function(statex)

For example the call,

derivative(PLUSEQUAL,2.,DIVERGENCE,statex,NULL);

executes the following equation,

State += 2.*DIVERGENCE(statex)

In particular the GRADIENT_NORMALIZED operator may be used to compute normals to a scalar field for use in smooth shading of isosurfaces. Assume that a node State object contains a continuous scalar field. Smoothly varying node normals to the scalar field may be generated by first using derivative() to compute normal vectors at element nodes and then using map() to map the element node normals to nodes. The mapping operation is required since the computation of gradient normals at element nodes will, in general, result in discontinuous values of the gradients between elements.

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State and statex entity types are not proper or the derived data type of statex does not match the proper data type for the function.
NULLOBJECT is generated if the State object does not have a MeshInterface attribute object.

Parameters:	operation – `Operation` factor – Floating point coefficient function – `DifferentialOperation` statex – Pointer to State operand object group – Pointer to Group object. If NULL, then all entities are assumed.
Returns:	Status

Status setGroupParameter(GroupOperation type, float param[])

Set group derivation parameters. The EXTENT parameters are two float values specifying scalar state extent, minimum scalar value followed by maximum scalar value. The extent check includes the extreme values.

Parameters:	type – Parameter type ( `EXTENT` ) param – Specifies the float values that type will be set to
Returns:	Status

Status generateSortedEntities(Group *group, IdTranslator *sortedEntities)

Generate a list of entity indices and output in the sortedEntities object. The entities are placed in the sortedEntities object sorted by their scalar derived value in the State object. The previous contents of the State object are lost.

By default, for element node states, the average of the element node values is used as the sorting value. Optionally, the individual element node values can be used as the sorting value by setting SORT_ELEMENT_AVERAGE off in setIntegerParameter() .

By default, the values are sorted from negative to positive. The sorting can be changed from positive to negative by setting SORT_DESCENDING in setIntegerParameter() . The absolute value can be sorted by setting SORT_ABSOLUTE_VALUE in setIntegerParameter() .

Errors

VALUE is generated if group is not the same entity type as the state.
OPERATION is generated if the State object does not have a scalar derived type.

Parameters:	group – Pointer to Group object. If NULL, then all entities are assumed. sortedEntities – [out] Pointer to IdTranslator object of sorted entities
Returns:	Status

Status generateElementGroup(GroupOperation operation, Group *group, Group *generatedGroup)

Derive a group of elements from an input group of elements using a specified operation. The output generatedGroup must have been previously created and defined as an element group. Note that generatedGroup is not cleared by this function, the derived element entities are added to any existing elements in the output generatedGroup. Any entities for which data has not been defined are skipped.

For the operation EXTENT and OUTBOUND the extent limits are specified using setGroupParameter() . If any of the data components at an element satisfy the test condition then the element is added to the group.

The operation DEFINED adds all elements for which data has been defined.

The operations LOCAL_MIN , LOCAL_MAX or LOCAL_MINMAX adds all elements which are a local data minimum, maximum or either minimum or maximum. The State must either be a scalar State or the current derived quantity is a scalar.

Errors

VALUE is generated if group is not an element group.
OPERATION is generated if State parent type is not element.

Parameters:	operation – `GroupOperation` group – Pointer to Group object of elements. If NULL, then all elements are assumed. generatedGroup – [out] Pointer to Group object to hold generated elements
Returns:	Status

Status generateNodeGroup(GroupOperation operation, Group *group, Group *generatedGroup)

Derive a group of nodes from an input group of nodes using a specified operation. The output generatedGroup must have been previously created and defined as a node group. Note that generatedGroup is not cleared by this function, the derived node entities are added to any existing nodes in the output generatedGroup. Any entities for which data has not been defined are skipped.

For the operation EXTENT and OUTBOUND the extent limits are specified using setGroupParameter() . If any of the data components at a node satisfy the test condition then the node is added to the group.

The operation DEFINED adds all nodes for which data has been defined.

The operations LOCAL_MIN , LOCAL_MAX or LOCAL_MINMAX adds all nodes which are a local data minimum, maximum or either minimum or maximum. The State must either be a scalar State or the current derived quantity is a scalar.

Errors

VALUE is generated if group is not a node group.
OPERATION is generated if State parent type is not node.

Parameters:	operation – `GroupOperation` group – Pointer to Group object of nodes. If NULL, then all nodes are assumed. generatedGroup – [out] Pointer to Group object to hold generated nodes
Returns:	Status

Status copy(State *source)

Make a copy of a State object. The contents of the source object are copied to this State object.

Parameters:	source – Pointer to the source State object to copy from
Returns:	Status

Status getCoordinateSystemIdAtEntity(int index, int *coordinateSystemId)

Get coordinate system identifier coordinateSystemId used in the system state for entity index.

Parameters:	index – Entity index to get coordinate system identifier coordinateSystemId – [out] Coordinate system identifier used for entity index
Returns:	Status

Results Manipulation

Overview

Local Coordinate Systems

Parallel Functions

MeshInterface member

Class Members Descriptions

Hello! I'm HOOPSY