Thesortcommand creates a sort key for chosen node or element attributes. Sort can be in ascending or descending order and will not alter current mesh object values (though theline_graphoption will create three new attributes; see below). One can perform a sort on a single attribute or in the case ofindexorranksorting, one can perform a multi-key sort. Theline_graphsort does not sort on an attribute but instead sorts line segment elements into a reasonable order based on connectivity. In each case the sort key that is created can be used in thereordercommand to change the node or element ordering of the mesh object.

The command parameters include the cmo_name, followed by the sort_type. The ordering is indicated byascendingordescending. A new attribute is created with the sort_key_name. For thebins,index, andrankoptions, sorting is performed on the sort_attributes which can be a single attribute name or a list of attribute names. This list is formed with attribute names in_att1, in_att2, through in_attn. Theline_graphoption does not take any attributes as arguments because it sorts based on the connectivity of the elements, which must be line segments.

cmo_name:
The choices for first parameter
are the name of a valid mesh object or **-def-** which select the currently
active mesh object.

sort_type: The sorting methods include
**bins**, **index**, **rank** and **line_graph**.

binsA single-key sort which assigns each in_att1 value a bin number. If in_att1 is an integer then bins each have a unique integer value associated with them. If in_att1 is a real number, bins are created with values which are within +-epsilon of each other, where epsilon=1.e-10*abs(real_bin_value). If all array values are unique, then the maximum value of the index array will equal the number of entries in the sorted list. Otherwise, the maximum value of the index array will be less than the number of entries in the sorted list but will equal the number of unique entries in the list.With the

binsmethod, an optional user specified epsilon multiplier,epsilon_user, will override the default value of 1.e-10.

indexConstructs a single or multi-key index table such that in_att1(ikey(1)) is the first entry in the sorted array, in_att1(ikey(2)) is the second, etc.

rankConstructs a single or multi-key rank table such that the tables ith entry give the rank of the ith entry of the sorted arrays. The rank table is derived from the index table by:

foreach j = 1,N

rank(index(j)) = j

end

line_graphThis option requires all elements to be line segments, and it arranges them in a reasonable order. In particular, it makes the following guarantees:The sorted order for components which are not polylines or polygons is unspecified, but it will usually be reasonable because the underlying algorithm visits the edges via depth first search.

- Each connected component will be arranged together.
- Polylines (chains of line segments with no branching or loops) will be in order from one end to the other.
- Polygons will be in order starting from one segment and looping back around to the same place.
The

line_graphoption forelementsalso generates the following three integer element attributes:The

- cid: A component id for distinguishing separate connected components. Each connected component receives a unique positive integer starting from one. This allows you to identify all the edges in a particular component by selecting all elements with a particular component id.
- ctype: The component type, represented as an integer from 1 to 5.

- 1 (Polyline)
- A connected chain of segments with no branches or loops.
- 2 (Tree)
- A connected acyclic component.
- 3 (Polygon)
- A component consisting solely of a single loop.
- 4 (Shared Edges)
- A component which has a pair of cycles with a shared edge.
- 5 (Other)
- Anything which does not fit into the above categories.
- loop_id: This is a unique positive integer assigned to each simple cycle. Edges that are not part of a cycle receive a default value of zero. If an edge is shared (i.e. part of more than one cycle) then it will be labeled with only one of its cycles. In this case, the cycle corresponding to the label is not fully specified because there is more than one right answer.
line_graphoption fornodesis based on the option for elements, except that it does not create extra attributes. Based on the sorted elements, the nodes will be reordered in the same sequence. This is necessary for triangulation as "TRIANGULATE" routine requires the nodes to be in clockwise/counterclockwise order.

sort_order: Choose between

Sort sort_attributes inascendingorderascendingdescendingSort sort_attributes indescendingorder

The **line_graph** sort will ignore this option,
but it still expects the field to be present for consistency with the other sort
variations.

sort_key_name: The name for an integer vector (VINT) which will hold the output sort key values. If the name exists it will be used, if it does not exist it will be created. If no name is given for sort_key_name A name will be created which will be the concatination of

sort_attributes: The name of one or more existing attribute names. Each attribute will be used as a node of element based array upon which the sorting routine will sort. Multi-key sorts can have an arbitrary number of input attributes. Attribute in_att1(n) has priority over in_att2(n) in breaking ties. Note: all attributes are put into a real*8 work array before being sent to the sort routine.

SINGLE KEY bins FORMAT:

MULTI-KEY FORMAT:sort/ cmo_name /bins/ [] / sort_key_name / sort_attribute / [epsilon_user]ascending| descending

LINE GRAPH FORMAT:sort/ cmo_name /index | rank/ [] / sort_key_name / in_att1, in_att2, in_att3 ...ascending| descending

sort/ cmo_name /line_graph/ [] / sort_key_name / [ascending| descending]elements| nodes

EXAMPLES:

sort/ cmo /index / ascending/ ikey / imt zic yic xic

Multi-key sort first by imt then to break ties consider z coordinate, then if there are further ties, use y coordinate. Use x coordinate as final tie breaker.

sort/ cmo/ rank / descending/ ikey / yic

Produce ranking of nodes based on y coordinate in descending order.

sort/ cmo /index /-def-/-def-/ xic yic zic

Produce index of noded coordinates. This would be like a line sweep sort where the sweep is first along x coordinate then y then z.

sort/ cmo /bins / ascending/ i_index / xicsort/ cmo /bins / ascending/ j_index / yicsort/ cmo /bins / ascending/ k_index / zic

If the cmo were a finite difference grid of points, the above three commands would produce the finite difference indexing. All points with the same x value would be in the same i_index bin, all points with the same y value would be in the same j_index bin, etc.

sort/ cmo /line_graph/ascending/ ikey / elements

Sort the line segment elements into a reasonable order based on connectivity. This also creates attributes cid, ctype, and loop_id (see above).

sort / xyz / bins

Old version no longer supported but syntax will work. Result is the same as previous three commands.

LINKS:

Example 1 for sort and reorder

Example 2 for sort and reorder

BEGIN OLD FORMAT - No longer supported but syntax will still work.

Old Format - **sort / xyz / [ index | bins | rank** ]

sort/xyz/index - sorts the x,y,z coordinate integer arrays i_index, j_index, k_index such that xic(i_index(i)) i=1,..nnodes lists the coordinate in ascending order.END OLD FORMAT - No longer supported but syntax will still work.

sort/xyz/bins - sorts the x,y,z coordinates and assigns each i_index, j_index, k_index values in ascending order of the bin number of the sorted list.

sort/xyz/rank - sorts the x,y,z coordinates and assigns each i_index, j_index, k_index values the ranking of the node in the sorted list.

If all array values are unique, then the maximum value of the index array will equal the number of entries in the sorted list. Otherwise, the maximum value of the index array will be less than the number of entries in the sorted list but will equal the number of unique entries in the list.

For example given x = 0, 1, 2, 1, 0

sort/xyz/index returns i_index = 5, 1, 4, 2, 3

sort/xyz/bins returns i_index = 1, 2, 3, 2, 1

sort/xyz/rank returns i_index = 2, 4, 5, 3, 1