Basic Functions > List Processor > D.1 Understanding the List Processor
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX''">XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX''">   
D.1 Understanding the List Processor
Introduction
The list processor interprets the contents of all select databoxes. All select databoxes in Patran expect character strings as input. The character strings may be supplied by the graphics system when the user selects an entity from a viewport or the string can be typed, or pasted in directly. The character strings are called “pick lists.”
The pick list syntax is common throughout Patran which means that for each application all of the select features are available at all times. Because the interpretation of input data is so general, the description must be specific. If the application is expecting nodes as input, it is not enough just to type their ids, the word “Node” must be added to the beginning.
Examples of pick list syntax are:
Node 9 18 
Elm 1 4 5 8
Quad 4
hpat 10
Surface 1.2
In addition to referring to entities which exist in the database, Patran allows selection of immediate geometric entities such as a straight line defined by two endpoints. As long as the application is not associating attributes to the entity, it is a valid option. An example of the syntax of a straight line defined by two points is:
Construct 2PointCurve(Evaluate Geometry(Point 2 ))(Evaluate Geometry(Point 4 ))
Many of the items in pick lists can be abbreviated. An example of the abbreviation of the previous pick list is:
Co 2PointCurve( Ev Geo (G2))( Ev Geo (G4))
In most cases, the immediate geometric entities are defined by cursor picking in the graphics viewport and the pick list is created, making it unnecessary to memorize the pick list syntax.
This section is intended to assist you in understanding the syntax used by the list processor so that, not only will you understand the interaction between the Patran selection mechanism (via the select menus) and Patran application programs, but you will also be able to modify improperly-selected entries to suit your needs. Each area in this section contains syntax definitions as well as examples of the syntax in use.
 
Important:  
Wherever white space is necessary to separate two items from one another, the list processor will accept any number of blank characters, commas, or slashes without distinction.
Geometry
Points
Referring to points which already exist in the database
The simplest form of point selection yields pick lists which refer to points that already exist in the Patran database. The syntax for this form can be described symbolically as follows:
 
<pointInDatabaseList>
::=
<pointKW> <pointLabelList> { <pointLabelList> | <pointInDatabaseList> } 0:n
<pointKW>
::=
Point | Pnt | Pt | Grid | Gr | G
<pointLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | #
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑1
List Processor Syntax
Meaning
Pt1
Point 1.
Point 1 2 3
Points 1, 2, and 3.
Point 1:2 Gr 3
Points 1, 2, and 3.
G1T9B2
Points 1, 3, 5, 7, and 9.
Grid 1,3/5,7,9
Points 1, 3, 5, 7, and 9.
Grid 1 Pt 3:5:2 / G7 G9
Points 1, 3, 5, 7, and 9.
Referring to points which exist as the vertexes of other entities which exist in the database
Patran allows applications to use points in a topological context for any operation where points are valid. That is, if it is more convenient to refer to points in their vertex context to edges or faces, Patran will allow it. The syntax for using this form can be described symbolically as:
 
<pointTopologicallyInDatabaseList>
::=
{ <curveVertexList> } 0:n { <surfaceVertexList> } 0:n { <solidVertexList> } 0:n
<curveVertexList>
::=
<curveKW> <singleToplogicalIndentLabelList> { <singleToplogicalIndentLabelList> } 0:n 
<surfaceVertexList>
::=
<surfaceKW> <doubleTopologicalIndentLabelList> { <doubleTopologicalIndentLabelList> } 0:n
<solidVertexList>
::=
<solidKW> <tripleTopologicalIndentLabelList> { <tripleTopologicalIndentLabelList>} 0:n 
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<singleTopologicalIndentLabelList> 
::=
<int>.<int> | <int> <throughKW> <int>.<int> | <int> <throughKW> <int> <byKW> <int>.<int>
<surfaceKW>
::=
Surface | Surf | Srf | C | Patch | Pa | P
<doubleTopologicalIndentLabelList>
::=
<int>.<int>.<int> | <int> <throughKW> <int>.<int> .<int> | <int> <throughKW> <int> <byKW> <int>.<int>.<int>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp | H
<tripleTopologicalIndentLabelList>
::=
<int>.<int> .<int>.<int> | <int> <throughKW> <int>.<int>.<int>.<int> | <int> <throughKW> <int> <byKW> <int>.<int>.<int>.<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑2
List Processor Syntax
Meaning
Curve 1.1
Vertex 1 of curve 1.
Curve 2.1, Surface 3.2.1, Solid 4.3.2.1
Vertex 1 of curve 2, vertex 1 of edge 2 of surface 3, vertex 1 of edge 3 of face 2 of solid 1.
Surface 1:10:3.1.2
Vertex 2 of edge 1 of surfaces 1, 4, 7, and 10.
Referring to points by referring to finite element nodes which exist where a point is to be located
Point lists can also be formed by the selection mechanism from finite element nodes which already exist in the Patran database. Any application which uses the point list to gather [X Y Z] geometry for further processing, rather than for label or ID information, will accept point lists which coerce values from the finite element node definitions. The syntax for this form is described symbolically as:
 
<pointFromNodeInDatabaseList>
::=
<nodeKW> <nodeLabelList> { <nodeLabelList> | <pointFromNodeInDatabaseList> } 0:n
<nodeKW>
::=
Node | Nde | N
<nodeLabelList> 
::=
<int> | <int> <throughKW> <int>| <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑3
List Processor Syntax
Meaning
Node 20:30
The locations of nodes 20 through 30 will be used as the [X Y Z] for an application requesting [X Y Z] information.
NDE 30:20:-2 , N 29:21:-2
The locations of nodes 30, 28, 26, 24, 22, 20, 29, 27, 25, 23, and 21 will be used as the [X Y Z] for an application requesting [X Y Z] information.
Referring to points by selection mechanism screen position picks
This form of point selection creates pick lists which allow applications to use points which do not exist in the database, but are convenient to describe by picking approximations on the display. If desired, such points can also be manually tweaked by inputting their absolute [X Y Z]. This is useful when the selection mechanism yields points with a Z coordinate of zero, while the desired point has a non-zero Z coordinate. The syntax for this type of pick list can be described symbolically as:
 
<pointImmediateXyzList>
::=
{ [ <float> <float> <float>] } 1:n
<float>
::=
{ <int> } 0:1 { . } 0:1 { <int> } 0:1 { e <int> } 0:1 
<int>
::= 
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
 
Table D‑4
List Processor Syntax
Meaning
[1 2 3]
A point at x=1, y=2, z=3 is to be used as the [X Y Z] for an application requesting [X Y Z] information.
[1 2 3] [4 5 6] [7 8 9]
Points at x=1, y=2, z=3; x=4, y=5, z=6; x=7, y=8, z=9 will be used as the [X Y Z] for an application requesting [X Y Z] information.
Referring to points by defining their 3 coordinates
The user is allowed to generally create a point on the fly for applications with which to work. The string in the databox contains general notation for the generation of [X Y Z] data for applications to use. One may start with a selection generated screen pick, and snap it to the X, Y or Z of a given point or node. Or one may decide to directly input the specific [X Y Z] necessary for correct geometry generation. The syntax for this type of pick list can be described symbolically as:
 
<pointImmediateList>
::=
{ [ <xPortion> <yPortion> <zPortion>] } 1:n
<xPortion>
::=
<float> | x <pointLabel> | xp <pointLabel> | xn <nodeLabel>
<yPortion>
::=
<float> | y <pointLabel> | yp <pointLabel> | yn <nodeLabel>
 
<zPortion>
::=
<float> | z <pointLabel> | zp <pointLabel> | zn <nodeLabel>
 
<float>
::=
{ <int> } 0:1 { . } 0:1 { <int> } 0:1 { e <int> } 0:1 
<pointLabel>
::=
<int>
<nodeLabel>
::=
<int>
<int>
::= 
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
 
Table D‑5
List Processor Syntax
Meaning
[x1/yn2/100]
A point at x=the x coordinate of point 1, y=the y coordinate of node 2, z=100 is to be used as the [X Y Z] for an application requesting [X Y Z] information.
[xn1,yn2,zn3] [xp1 yp2 zp3]
Points at x=the x coordinate of node 1, y=the y coordinate of node 2, z=the z coordinate of node 3; x=the x coordinate of point 1, y=the y coordinate of point 2, z=the z coordinate of point 3 will be used as the [X Y Z] for an application requesting [X Y Z] information.
Referring to points defined by the intersection of two curves
Patran allows applications to work with points defined by the intersection of two curves, as well as work with single point selection. The use of this type of expression can cut down on unnecessary “construction geometry”, which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a point via the two line intersection mechanism, select two lines (by any of the available line selection mechanisms) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. When the list processor evaluates the expression, if no intersections are found, an error is returned. In the case of multiple intersections, the first solution found is used. The syntax for this type of expression is diagrammatically described as:
 
<2CurvePointExpression>
::=
<constructKW> <2CurvePointKW> <curveGeometryExpression> <curveGeometryExpression>
constructKW
::=
Construct | Co | Make
<2CurvePointKW>
::=
2CurvePoint | 2CrvPt | 2CP
<curveGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <curveExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<curveExpression>
::=
<curveInDatebaseExpression> | <curveConstructionExpression>
<curveInDatabaseExpression>
::=
<curveByDatabaseLabelExpression> | <surfaceEdgeExpression> | <solidEdgeExpression>
<curveByDatabaseLabelExpression>
::=
<curveKW> <curveLabel>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<surfaceEdgeExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<solidEdgeExpression>
::=
<solidKW><solidLabel>.<solidFace>.
<solidFaceEdge>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<curveConstructionExpression>
::=
<2PointCurveExpression> | <2SurfaceCurveExpression>
 
Note:  
The syntax for <2PointCurveExpression> and <2SurfaceCurveExpression> may be found under the appropriate headings in this section.
Referring to points defined by the intersection of a curve and a surface
Patran will also allow applications to work with points defined by the intersection of a curve and a surface, as well as using a single point selection. The use of this type of expression can cut down on unnecessary “construction geometry,” which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a point via the curve surface intersection mechanism, select a surface and a curve (by any of the available selection mechanisms) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. When the list processor evaluates the expression, if no intersections are found, an error is returned. In the case of multiple intersections, the first solution found is used. The syntax for this type of expression is diagrammatically described as:
 
<curveSurfacePointExpression>
::=
<constructKW> <curveSurfacePointKW> <curveGeometryExpression> <surfaceGeometryExpression>
constructKW
::=
Construct | Co | Make
<curveSurfacePointKW>
::=
CurveSurfacePoint
<curveGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <curveExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<curveExpression>
::=
<curveInDatebaseExpression> | <curveConstructionExpression>
<curveInDatabaseExpression>
::=
<curveByDatabaseLabelExpression> | <surfaceEdgeExpression> | <solidEdgeExpression>
<curveByDatabaseLabelExpression>
::=
<curveKW> <curveLabel>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<surfaceEdgeExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<solidEdgeExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<curveConstructionExpression>
::=
<2PointCurveExpression> | <2SurfaceCurveExpression> 
<surfaceGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <surfaceExpression> ) )
<surfaceExpresion>
::=
<surfaceInDatebaseExpression> | <surfaceConstructionExpression>
<surfaceInDatabaseExpression>
::=
<surfaceByDatabaseLabelExpression> | <solidEdgeExpression>
<surfaceByDatabaseLabelExpression>
::=
<surfaceKW> <surfaceLabel>
<surfaceConstructionExpression>
::=
<2CurveSurfaceExpression>
 
Note:  
The syntax for <2PointCurveExpression>, <2SurfaceCurveExpression>, and <2CurveSurfaceExpression> may be found under the appropriate headings in this section.
 
Table D‑6
List Processor Syntax
Meaning
Construct CurveSurfacePoint (Evaluate Geo (Curve 1)) (Evaluate Geo (Surface 2))
A point at the intersection of curve 1 and surface 2 will be used for an application requesting [X Y Z] information for a point.
Make CurveSurfacePoint (Ev Geo (S1.2)) (Ev Geo (S2))
A point at the intersection of the 2nd edge of surface 1 with surface 2 will be used for an application requesting [X Y Z] information for a point.
Co CurveSurfacePoint (Eval GeometryDef (Solid 1.2.3)) (Evaluate GeometryDefinition (Surface 4))
A point at the intersection of the 3rd edge of the 2nd face of solid 1 with surface 4 will be used for an application requesting [X Y Z] information for a point.
Referring to points defined by the closest approach of a point to a curve
Patran allows applications to work with points defined by the closest approach of a point to a curve, as well as using a single point selection. The use of this type of expression can cut down on unnecessary “construction geometry,” which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a point via the point closest approach to a curve mechanism, select a curve and a point (by any of the available selection mechanisms) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<PointCurvePointExpression>
::=
<constructKW> <pointCurvePointKW> <pointGeometryExpression> <curveGeometryExpression>
constructKW
::=
Construct | Co | Make
<pointCurvePointKW>
::=
PointCurvePoint
<pointGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <pointExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<pointExpression>
::=
<pointInDatebaseExpression> | <pointConstructionExpression>
<pointInDatabaseExpression>
::=
<pointByDatabaseLabelExpression> | <curveVertexExpression> | <surfaceVertexExpression> | <solidVertexExpression>
<pointByDatabaseLabelExpression>
::=
<pointKW> <pointLabel>
<pointKW>
::=
Point | Pnt | Pt | P | grid# | Gr | G
<pointLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<curveVertexExpression>
::=
<curveKW> <curveLabel>.<curveVertex>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<curveVertex>
::=
<int>
<surfaceVertexExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>.<surfaceEdgeVertex>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<surfaceEdgeVertex>
::=
<int>
<solidVertexExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>.<solidFaceEdgeVertex>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<solidFaceEdgeVertex>
::=
<int>
<pointConstructionExpression>
::=
<2CurvePointExpression> | <pointCurvePointExpression> | <pointSurfacePointExpression> | <curveSurfacePointExpression>
<curveGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <curveExpression> ) )
<curveExpresion>
::=
<curveInDatebaseExpression> | <curveConstructionExpression>
<curveInDatabaseExpression>
::=
<curveByDatabaseLabelExpression> | <surfaceEdgeExpression> | <solidFaceEdgeExpression>
<curveByDatabaseLabelExpression>
::=
<curveKW> <curveLabel>
<surfaceEdgeExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>
<solidFaceEdgeExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>
<curveConstructionExpression>
::=
<2PointCurveExpression> | <2SurfaceCurveExpression>
 
Note:  
The syntax for <2CurvePointExpression>, <pointSurfacePointExpression>, <curveSurfacePoint>, <2PointCurveExpression>, and <2SurfaceCurveExpression> may be found under the appropriate headings in this section.
 
Table D‑7
List Processor Syntax
Meaning
Construct PointCurvePoint (Evaluate Geo (Point 1)) (Evaluate Geo (Curve 2))
A point at the closest approach of point 1 to curve 2 will be used for an application requesting [X Y Z] information for a point.
Make PointCurvePoint (Ev Geo (S1.2.1)) (Ev Geo (L2))
A point at the intersection of the 1st vertex of the 2nd edge of surface 1 with curve 2 will be used for an application requesting [X Y Z] information for a point.
Co PointCurvePoint (Eval GeometryDef (Solid 1.2.3.1)) (Evaluate GeometryDefinition (Curve 4))
A point at the intersection of the 1st vertex of the 3rd edge of the 2nd face of solid 1 with curve 4 will be used for an application requesting [X Y Z] information for a point.
Referring to points defined by the closest approach of a point to a surface
Patran allows applications to work with points defined by the closest approach of a point to a surface, as well as using a single point selection. The use of this type of expression can cut down on unnecessary “construction geometry,” which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a point via the point closest approach to a surface mechanism, select a surface and a point (by any of the available selection mechanisms) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<pointSurfacePointExpression>
::=
<constructKW> <pointSurfacePointKW> <pointGeometryExpression> <surfaceGeometryExpression>
constructKW
::=
Construct | Co | Make
<pointSurfacePointKW>
::=
PointSurfacePoint
<pointGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <pointExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<pointExpression>
::=
<pointInDatebaseExpression> | <pointConstructionExpression>
<pointInDatabaseExpression>
::=
<pointByDatabaseLabelExpression> | <curveVertexExpression> | <surfaceVertexExpression> | <solidVertexExpression>
<pointByDatabaseLabelExpression>
::=
<pointKW> <pointLabel>
<pointKW>
::=
Point | Pnt | Pt | grid# | Gr | G
<pointLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<curveVertexExpression>
::=
<curveKW> <curveLabel>.<curveVertex>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<curveVertex>
::=
<int>
<surfaceVertexExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>.<surfaceEdgeVertex>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<surfaceEdgeVertex>
::=
<int>
<solidVertexExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>.<solidFaceEdgeVertex>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<solidFaceEdgeVertex>
::=
<int>
<pointConstructionExpression>
::=
<2CurvePointExpression> | <pointCurvePointExpression> | <pointSurfacePointExpression> | <curveSurfacePointExpression>
<surfaceGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <surfaceExpression> ) )
<surfaceExpresion>
::=
<surfaceInDatebaseExpression> | <surfaceConstructionExpression>
<surfaceInDatabaseExpression>
::=
<surfaceByDatabaseLabelExpression> | <solidFaceExpression>
<surfaceByDatabaseLabelExpression>
::=
<surfaceKW> <surfaceLabel>
<solidFaceExpression>
::=
<solidKW> <solidLabel>.<solidFace>
<surfaceConstructionExpression>
::=
<2CurveSurfaceExpression>
 
Note:  
The syntax for <2CurvePointExpression>, <pointSurfacePointExpression>, <curveSurfacePoint>, and <2CurveSurfaceExpression> may be found under the appropriate headings in this section.
 
Table D‑8
List Processor Syntax
Meaning
Construct PointSurfacePoint (Evaluate Geo (Point 1)) (Evaluate Geo (Surface 2))
A point at the closest approach of point 1 to surface 2 will be used for an application requesting [X Y Z] information for a point.
Make PointSurfacePoint (Ev Geo (S1.2.1)) (Ev Geo (S2))
A point at the closest approach of the 1st vertex of the 2nd edge of surface 1 with surface 2 will be used for an application requesting [X Y Z] information for a point.
Co PointSurfacePoint (Eval GeometryDef (Solid 1.2.3.1)) (Evaluate GeometryDefinition (Surface 4))
A point at the intersection of the 1st vertex of the 3rd edge of the 2nd face of solid 1 with surface 4 will be used for an application requesting [X Y Z] information for a point.
Curves
Referring to curves which already exist in the database
The simplest form of curve selection yields pick lists which refer to curves that already exist in the Patran database. The syntax for this form can be described symbolically as follows:
 
<curveInDatabaseList>
::=
<curveKW> <curveLabelList> { <curveLabelList> | <curveInDatabaseList> } 0:n
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑9
List Processor Syntax
Meaning
C1
Curve 1.
Curve 1 2 3
Curves 1, 2, and 3.
Curve 1:2 Li 3
Curves 1, 2, and 3.
L1T9B2
Curves 1, 3, 5, 7, and 9.
Line 1,3/5,7,9
Curves 1, 3, 5, 7, and 9.
Line 1 Crv 3:5:2 / L7 L9
Curves 1, 3, 5, 7, and 9.
Referring to curves which exist as the edges of other entities which exist in the database
Patran allows applications to use curves in a topological context for any operation where curves are valid. That is, if it is more convenient to refer to curves in their edge context to faces, Patran will allow it. The syntax for using this form can be described symbolically as:
 
<curveTopologicallyInDatabaseList>
::=
{ <surfaceEdgeList> } 0:n { <solidEdgeList> } 0:n
<surfaceEdgeList>
::=
<surfaceKW> <singleToplogicalIndentLabelList> { <singleToplogicalIndentLabelList> } 0:n 
<solidEdgeList>
::=
<solidKW> <doubleTopologicalIndentLabelList> { <doubleTopologicalIndentLabelList> } 0:n
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P
<singleTopologicalIndentLabelList> 
::=
<int>.<int> | <int> <throughKW> <int>.<int> | <int> <throughKW> <int> <byKW> <int>.<int>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp | H
<doubleTopologicalIndentLabelList>
::=
<int>.<int>.<int> | <int> <throughKW> <int>.<int> .<int> | <int> <throughKW> <int> <byKW> <int>.<int>.<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑10
List Processor Syntax
Meaning
Surface 1.1
Edge 1 of surface 1.
Surface 2.1, Solid 3.2.1
Edge 1 of surface 2, edge 1 of face 2 of solid 3.
Hpat 1:10:3.1.2
Edge 2 of face 1 of hyperpatches 1, 4, 7, and 10.
Referring to curves defined by a straight line between two points
Patran allows applications to work with curves defined by a straight line between two points in a form that is almost as easy for the user to work with as single curve selection. The use of this type of expression can cut down on unnecessary “construction geometry,” which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a curve via the two point line mechanism, select two points (by any of the available selection mechanisms, including such methods as construction of points through intersection, etc.) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<2PointCurveExpression>
::=
<constructKW> <2PointCurveKW> <pointGeometryExpression> <pointGeometryExpression>
constructKW
::=
Construct | Co | Make
<2PointCurveKW>
::=
2PointCurve
<pointGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <pointExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<pointExpression>
::=
<pointInDatebaseExpression> | <pointConstructionExpression>
<pointInDatabaseExpression>
::=
<pointByDatabaseLabelExpression> | <curveVertexExpression> | <surfaceVertexExpression> | <solidVertexExpression>
<pointByDatabaseLabelExpression>
::=
<pointKW> <pointLabel>
<pointKW>
::=
Point | Pnt | Pt | P | grid# | Gr | G
<pointLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<curveVertexExpression>
::=
<curveKW> <curveLabel>.<curveVertex>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<curveVertex>
::=
<int>
<surfaceVertexExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>.<surfaceEdgeVertex>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<surfaceEdgeVertex>
::=
<int>
<solidVertexExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>.<solidFaceEdgeVertex>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<solidFaceEdgeVertex>
::=
<int>
<pointConstructionExpression>
::=
<2CurvePointExpression> | <pointCurvePointExpression> | <pointSurfacePointExpression> | <curveSurfacePointExpression>
 
Note:  
The syntax for <2CurvePointExpression>, <pointCurvePoint>, <pointSurfacePointExpression>, and <curveSurfacePoint> may be found under the appropriate headings in this section.
  
Table D‑11
List Processor Syntax
Meaning
Construct 2PointCurve (Evaluate Geo (Point 1)) (Evaluate Geo (Point 2))
A curve defined by a straight line between point 1 and point 2 will be used for an application requesting the geometry of a curve.
Make 2PointCurve (Ev Geo (S1.2.1)) (Ev Geo (G2))
A curve defined by a straight line between the 1st vertex of the 2nd edge of surface 1 with point 2 will be used for an application requesting the geometry of a curve.
Co 2PointCurve (Eval GeometryDef (Solid 1.2.3.1)) (Evaluate GeometryDefinition
(Point 4))
A curve defined by a straight line between the 1st vertex of the 3rd edge of the 2nd face of solid 1 with point 4 will be used for an application requesting the geometry of a curve.
Referring to curves defined by the intersection of two surfaces
Patran allows applications to work with curves defined by the curve formed between the intersection of two surfaces in a form that is almost as easy for the user to work with as single curve selection. The use of this type of expression can cut down on unnecessary “construction geometry,” which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a curve via the two point surface intersect mechanism, select two surfaces (by any of the available selection mechanisms), including such methods as construction of surfaces through two curve rule, etc.) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<2SurfaceCurveExpression>
::=
<constructKW> <2SurfaceCurveKW> <surfaceGeometryExpression> <surfaceGeometryExpression>
constructKW
::=
Construct | Co | Make
<2SurfaceCurveKW>
::=
2SurfaceCurve
<surfaceGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <surfaceExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<surfaceExpression>
::=
<surfaceInDatebaseExpression> | <surfaceConstructionExpression>
<surfaceInDatabaseExpression>
::=
<surfaceByDatabaseLabelExpression> | <solidFaceExpression>
<surfaceByDatabaseLabelExpression>
::=
<surfaceKW> <surfaceLabel>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P
<surfaceLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<solidFaceExpression>
::=
<solidKW> <solidLabel>.<solidFace>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<surfaceConstructionExpression>
::=
<2CurveSurfaceExpression>
 
Note:  
The syntax for <2CurveSurfaceExpression> may be found under the appropriate heading in this section.
 
Table D‑12
List Processor Syntax
Meaning
Construct 2SurfaceCurve (Evaluate Geo (Surface 1)) (Evaluate Geo (Surface 2))
A curve defined by the intersection between surface 1 and surface 2 will be used for an application requesting the geometry of a curve.
Make 2SurfaceCurve (Ev Geo (S1.2)) (Ev Geo (P2))
A curve defined by a straight line between the 1st face of surface 1 with surface 2 will be used for an application requesting the geometry of a curve.
Co 2SurfaceCurve (Eval GeometryDef (Solid 1.2)) (Evaluate GeometryDefinition (Surface 4))
A curve defined by a straight line between the 1st face of solid 1 with surface 4 will be used for an application requesting the geometry of a curve.
Referring to a curve and a parametric location along the curve
In the sections of Patran which call for user input of the form of a curve along with a point constrained along the curve (at a particular parametric u value along the curve), the list processor has a special format. The selection mechanism guides the user into selecting a curve and allows the selection of either a closest approach to a vertex on the curve, or a closest approach to some parametric position on the curve. Patran can then evaluate the resulting expression. The use of this type of expression can cut down on unnecessary “construction geometry”, which will be quite beneficial to clarity in the model definition phase. The syntax for this type of expression is diagrammatically described as:
 
<pointCurveUOnCurveExpression>
::=
<pointKW> <pointLabel> ( uKW uValue )
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<uKW>
::=
U
<uValue>
::=
<float>
<float>
::=
{ <int> } 0:1 { . } 0:1 { <int> } 0:1 { e <int> } 0:1
 
Table D‑13
List Processor Syntax
Meaning
Curve 1 (u 0)
Curve 1 at u = 0.0.
L1 (u .5)
Curve 1 at u = 0.5.
Crv 1 (U 1.000)
Curve 1 at u = 1.0.
Surfaces
Referring to surfaces which already exist in the database
The simplest form of surface selection yields pick lists which refer to surfaces that already exist in the Patran database. The syntax for this form can be described symbolically as follows:
 
<surfaceInDatabaseList>
::=
<surfaceKW> <surfaceLabelList> { <surfaceLabelList> | <surfaceInDatabaseList> } 0:n
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P
<surfaceLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑14
List Processor Syntax
Meaning
S1
Surface 1.
Surface 1 2 3
Surfaces 1, 2, and 3.
Surface 1:2 Pa 3
Surfaces 1, 2, and 3.
P1T9B2
Surfaces 1, 3, 5, 7, and 9.
Patch 1,3/5,7,9
Surfaces 1, 3, 5, 7, and 9.
Patch 1 Srf 3:5:2 / P7 P9
Surfaces 1, 3, 5, 7, and 9.
Referring to surfaces which exist as the faces of other entities which exist in the database
Patran allows applications to use surfaces in a topological context for any operation where surfaces are valid. That is, if it is more convenient to refer to surfaces in their face context to solids, Patran will allow it. The syntax for using this form can be described symbolically as:
 
<surfaceTopologicallyInDatabaseList>
::=
{ <solidFaceList> } 0:n 
<solidFaceList>
::=
<solidKW> <singleToplogicalIndentLabelList> { <singleToplogicalIndentLabelList> } 0:n 
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp | H
<singleTopologicalIndentLabelList> 
::=
<int>.<int> | <int> <throughKW> <int>.<int> | <int> <throughKW> <int> <byKW> <int>.<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑15
List Processor Syntax
Meaning
Solid 1.1
Face 1 of solid 1.
Solid 2.1, Solid 3.2
Face 1 of surface 2, face 2 of solid 3.
Hpat 1:10:3.1
Face 1 of hyperpatches 1, 4, 7, and 10.
Referring to surfaces defined by two curves
Patran allows applications to work with surfaces defined by ruling a surface between two curves in a form that is almost as easy for the user to work with as single surface selection. The use of this type of expression can cut down on unnecessary “construction geometry”, which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a surface via the two curve surface mechanism, select two curves (by any of the available selection mechanisms, including such methods as construction of curves through 2 points, etc.) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<2CurveSurfaceExpression>
::=
<constructKW> <2CurveSurfaceKW> <curveGeometryExpression> <curveGeometryExpression>
constructKW
::=
Construct | Co | Make
<2CurveSurfaceKW>
::=
2CurveSurface
<curveGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <curveExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<curveExpression>
::=
<curveInDatebaseExpression> | <curveConstructionExpression>
<curveInDatabaseExpression>
::=
<curveByDatabaseLabelExpression> | <surfaceEdgeExpression> | <solidEdgeExpression>
<curveByDatabaseLabelExpression>
::=
<curveKW> <curveLabel>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<surfaceEdgeExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<solidEdgeExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<curveConstructionExpression>
::=
<2PointCurveExpression> | <2SurfaceCurveExpression>
 
Note:  
The syntax for <2PointCurveExpression>, and <2SurfaceCurveExpression> may be found under the appropriate headings in this section.
 
Table D‑16
List Processor Syntax
Meaning
Construct 2CurveSurface (Evaluate Geo (Curve 1)) (Evaluate Geo (Curve 2))
A ruled surface defined between curve 1 and curve 2 will be used for an application requesting the geometry of a surface.
Make 2CurveSurface (Ev Geo (S1.2)) (Ev Geo (L2))
A ruled surface defined between the 2nd edge of surface 1 with curve 2 will be used for an application requesting the geometry of a surface.
Co 2CurveSurface (Eval GeometryDef (Solid 1.2.3)) (Evaluate GeometryDefinition
(Curve 4))
A ruled surface defined between the 3rd edge of the 2nd face of solid 1 with curve 4 will be used for an application requesting the geometry of a surface.
Referring to a surface and a parametric location on the surface
In the sections of Patran which call for user input of the form of a surface along with a point constrained on the surface (at a particular parametric uv value on the surface), the list processor has a special format. The selection mechanism guides the user into selecting a surface and allows the selection of either a closest approach to a vertex on the surface, closest approach to an edge of the surface, or a closest approach to some parametric position on the surface. Patran can then evaluate the resulting expression. The use of this type of expression can cut down on unnecessary “construction geometry”, which will be quite beneficial to clarity in the model definition phase. The syntax for this type of expression is diagrammatically described as:
 
<pointSurfaceUVOnSurfaceExpression>
::=
<surfaceKW> <surfaceLabel> ( uKW uValue ) (vKW vValue)
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P
<surfaceLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<uKW>
::=
U
<uValue>
::=
<float>
<float>
::=
{ <int> } 0:1 { . } 0:1 { <int> } 0:1 { e <int> } 0:1 
<vKW>
::=
V
<vValue>
::=
<float>
 
Table D‑17
List Processor Syntax
Meaning
Surface 1 (u 0) (v 0)
Surface 1 at u = 0.0, v = 0.0.
P1 (u .5) (v .5)
Surface 1 at u = 0.5, v = 0.5.
Srf 1 (U 1.000) (v 1.000)
Surface 1 at u = 1.0, v = 1.0.
Solids
Referring to solids which already exist in the database
The simplest form of solid selection yields pick lists which refer to solids that already exist in the Patran database. The syntax for this form can be described symbolically as follows:
<solidInDatabaseList>
::=
<solidKW> <solidLabelList> { <solidLabelList> | <solidInDatabaseList> } 0:n
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp | H
<solidLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑18
List Processor Syntax
Meaning
Solid 1
Solid 1.
Solid 1 2 3
Solids 1, 2, and 3.
Solid 1:2 Hp 3
Solids 1, 2, and 3.
H1T9B2
Solids 1, 3, 5, 7, and 9.
Hpat 1,3/5,7,9
Solids 1, 3, 5, 7, and 9.
Hpat 1 Sld 3:5:2 / H7 H9
Solids 1, 3, 5, 7, and 9.
Referring to solids defined by two surfaces
Patran allows applications to work with solids defined by ruling a solid between two surfaces in a form that is almost as easy for the user to work with as single solid selection. The use of this type of expression can cut down on unnecessary “construction geometry”, which will be quite beneficial to clarity in the model definition phase. A user must tell the selection mechanism that she wishes to select a solid via the two surface solid mechanism, select two surfaces (by any of the available selection mechanisms, including such methods as construction of surfaces between 2 curves, etc.) and allow the system to evaluate the resulting expression. This expression, while somewhat verbose, is quite general in its ability to conform to user expectations for robustness. The syntax for this type of expression is diagrammatically described as:
 
<2SurfaceSolidExpression>
::=
<constructKW> <2SurfaceSolidKW> <surfaceGeometryExpression> <surfaceGeometryExpression>
constructKW
::=
Construct | Co | Make
<2SurfaceSolidKW>
::=
2SurfaceSolid
<solidGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <solidExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<surfaceExpression>
::=
<surfaceInDatebaseExpression> | <surfaceConstructionExpression>
<surfaceInDatabaseExpression>
::=
<surfaceByDatabaseLabelExpression> | <solidFaceExpression>
<surfaceByDatabaseLabelExpression>
::=
<surfaceKW> <surfaceLabel>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P
<surfaceLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<solidFaceExpression>
::=
<solidKW> <solidLabel>.<solidFace>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp | H
<solidLabel
::=
<int>
<solidFace>
::=
<int>
<surfaceConstructionExpression>
::=
<2CurveSurfaceExpression>
 
Note:  
The syntax for <2CurveSurfaceExpression>, may be found under the appropriate heading in this section.
 
Table D‑19
List Processor Syntax
Meaning
Construct 2SurfaceSolid (Evaluate Geo (Surface 1)) (Evaluate Geo (Surface 2))
A ruled solid defined between surface 1 and surface 2 will be used for an application requesting the geometry of a solid.
Make 2SurfaceSolid (Ev Geo (Sld 1.2)) (Ev Geo (S2))
A ruled surface defined between the 2nd face of solid 1 with surface 2 will be used for an application requesting the geometry of a solid.
Co 2SurfaceSolid (Eval GeometryDef (Solid 1.2)) (Evaluate GeometryDefinition (Surface 4))
A ruled surface defined between the 2nd face of solid 1 with surface 4 will be used for an application requesting the geometry of a solid.
Finite Elements
Referring to nodes in the database
Node selection yields pick lists which refer to nodes that already exist in the Patran database. The syntax for this form is described symbolically below:
<nodeList>
::=
<nodeKW> <nodeLabelList> { <nodeLabelList> | <nodeList> } 0:n
<nodeKW>
::=
Node | Nde | N
<nodeLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑20
List Processor Syntax
Meaning
N1
Node 1.
Node 1 2 3
Nodes 1, 2, and 3.
Node 1:2 Nde 3
Nodes1, 2, and 3.
N1T9B2
Nodes 1, 3, 5, 7, and 9.
Node 1,3/5,7,9
Nodes 1, 3, 5, 7, and 9.
Node 1 Nde 3:5:2 / N7 N9
Nodes 1, 3, 5, 7, and 9.
Referring to elements in the database by their labels
Element selection yields pick lists which refer to elements by their labels for elements that already exist in the Patran database. The syntax for this form can be described symbolically as follows:
 
<elementList>
::=
<elementKW> <elementLabelList> { <elementLabelList> | <elementList> } 0:n
<elementKW>
::=
Element | Elem | Elm | El | E
<elementLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑21
List Processor Syntax
Meaning
E1
Element 1.
Element 1 2 3
Elements 1, 2, and 3.
Element 1:2 El 3
Elements, 2, and 3.
E1T9B2
Elements 1, 3, 5, 7, and 9.
Element 1,3/5,7,9
Elements 1, 3, 5, 7, and 9.
Element 1 Elm 3:5:2 / E7 E9
Elements 1, 3, 5, 7, and 9.
Referring to elements in the database by their attributes
Another way in which elements may be selected is by giving the list processor a description of the elements you would like to select from the database by their attributes, rather than an actual enumeration of the elements themselves. For example, you may wish to select all of the quad elements from the database to place them in a special group, all of the hex elements to place in a second group, and the remainder to place into a third group.
The syntax to accomplish this type of database element selection is:
<elementByAttributeList>
::=
<elementAttributeKW> <elementLabelList> { <elementLabelList> | <elementList> } 0:n
<elementAttributeKW>
::=
<basicElementAttributeKW> {<elementNodeCount>} 0:1
<basicElementAttributeKW>
::=
GE | GEL | GEQ | GEC | GE0D | GE1D | GE1DL | GE1DQ | GE1DC | GE2D | GE2DL | GE2DQ | GE2DC | GE3D | GE3DL | GE3DQ | GE3DC | Bar | Tria | Quad | Tet | Wedge | Hex
elementNodeCount
::=
<int>
<elementLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑22
keyWord
Dimension
Order
Edges
GE
*
*
*
GEL
*
linear
*
GEQ
*
quadratic
*
GEC
*
cubic
*
GE0D
0
*
*
GE1D
1
*
*
GE1DL
1
linear
*
GE1DQ
1
quadratic
*
GE1DC
1
cubic
*
GE2D
2
*
*
GE2DL
2
linear
*
GE2DQ
2
quadratic
*
GE2DC
2
cubic
*
GE3D
3
*
*
GE3DL
3
linear
*
GE3DQ
3
quadratic
*
GE3DC
3
cubic
*
Bar
1
*
*
Tria
2
*
3
Quad
2
*
4
Tet
3
*
6
Wedge
3
*
9
Hex
3
*
12
 
Table D‑23
List Processor Syntax
Meaning
Quad 1t#
All quad elements.
Quad4 1t#
All quad elements with 4 nodes.
Hex27 101:199:2
Hex elements with 27 nodes whose ID is an odd number between 100 and 199.
GE3DL 100:200:2 201:300:2
Linear 3-dimensional elements whose ID is either an even number between 100 and 200 or an odd number between 200 and 300. This selection may select combinations of tet, wedge, and/or hex linear elements such as tet4, wedge6 and/or hex elements.
GE3D 1:#.2.1
Edge 1 of face 2 of all 3-dimensional elements.
Referring to multi-point constraints (MPCs) in the database
MPC selection yields pick lists which refer to MPCs that exist in the Patran database. The syntax for this form can be described symbolically as follows: 
<mpcList>
::=
<mpcKW> <mpcLabelList> { <mpcLabelList> | <mpcList> } 0:n
<mpcKW>
::=
MPC
<mpcLabelList>
::=
<int> | <int> <throughKW> <int> | <int> <throughKW> <int> <byKW> <int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<throughKW>
::=
: | T | Through
<byKW>
::=
: | B | By
 
Table D‑24
List Processor Syntax
Meaning
MPC1
MPC 1.
MPC 1 2 3
MPCs 1, 2, and 3.
MPC 1:2 MPC 3
MPCs, 2, and 3.
MPC1T9B2
MPCs 1, 3, 5, 7, and 9.
MPC 1,3/5,7,9
MPCs 1, 3, 5, 7, and 9.
MPC 1 MPC 3:5:2 / MPC7 MPC9
MPCs 1, 3, 5, 7, and 9.
Miscellaneous
Referring to a coordinate frame
The selection mechanism generates a simple pick list for coordinate frames for the list processor to work with. Its syntax is:
<coordinateFrame>
::=
<coordinateFrameKW> <coordinateFrameLabel>
<coordinateFrameKW>
::=
CoordinateFrame | Coord | Cord | CF | Frame | Fr | F
<coordinateFrameLabel>
::=
<int> 
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
 
Table D‑25
List Processory Syntax
Meaning
Coord 0
Coordinate frame 0.
CoordinateFrame 10
Coordinate frame 10.
F3
Coordinate frame 3.
Defining an axis by referring to a coordinate frame
One way of defining an axis in Patran is to use an axis of a coordinate frame. The selection mechanism can guide you through filtering for picking only coordinate frames, and then using either the 1st, 2nd, or 3rd axis component of the selected coordinate frame as the axis of choice.
<coordinateFrameAxis>
::=
<coordinateFrameKW> <coordinateFrameLabel> . <coordainateFrameAxisNumber>
<coordinateFrameKW>
::=
CoordinateFrame | Coord | Cord | CF | Frame | Fr | F
<coordinateFrameLabel>
::=
<int> 
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<coordinateFrameAxisNumber>
::=
1 | 2 | 3
 
Table D‑26
List Processor Syntax
Meaning
Coord 0.2
The y axis of coordinate frame 0.
Coord 1.3
The z axis of coordinate frame 1.
Coord 10.1
The x axis of coordinate frame 10.
Defining an axis by referring to two points
Another way of defining an axis in Patran is to define the base and tip of a vector which corresponds to the axis to be constructed through the selection mechanism. Since the selection process uses the full power of the Patran selection mechanism and list processor, points may be defined with arbitrary complexity, such as the intersection of two lines being the base of an axis with the closest approach of a point to a surface being the tip.
 
<2PointAxisExpression>
::=
<constructKW> <2PointAxisKW> <pointGeometryExpression> <pointGeometryExpression> | { <pointInDatabaseExpression> <pointInDatabaseExpression> }
constructKW
::=
Construct | Co | Make
<2PointAxisKW>
::=
2PointAxis
<pointGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <pointExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<pointExpression>
::=
<pointInDatebaseExpression> | <pointConstructionExpression>
<pointInDatabaseExpression>
::=
<pointByDatabaseLabelExpression> | <curveVertexExpression> | <surfaceVertexExpression> | <solidVertexExpression>
<pointByDatabaseLabelExpression>
::=
<pointKW> <pointLabel>
<pointKW>
::=
Point | Pnt | Pt | P | grid# | Gr | G
<pointLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<curveVertexExpression>
::=
<curveKW> <curveLabel>.<curveVertex>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<curveVertex>
::=
<int>
<surfaceVertexExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>.<surfaceEdgeVertex>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<surfaceEdgeVertex>
::=
<int>
<solidVertexExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>.<solidFaceEdgeVertex>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<solidFaceEdgeVertex>
::=
<int>
<pointConstructionExpression>
::=
<2CurvePointExpression> | <pointCurvePointExpression> | <pointSurfacePointExpression> | <curveSurfacePointExpression>
 
Note:  
The syntax for <2CurvePointExpression>, <pointCurvePoint>, <pointSurfacePointExpression>, and <curveSurfacePoint> may be found under the appropriate headings in this section.
 
Table D‑27
List Processor Syntax
Meaning
Construct 2PointAxis (Evaluate Geo ([0 0 0])) (Evaluate Geo ([0 0 1]))
An axis is defined between [0 0 0] and [0 0 1].
{[0 0 0][0 0 1]}
An axis is defined between [0 0 0] and [0 0 1].
Construct 2PointAxis (Evaluate Geo (Point 1)) (Evaluate Geo (Point 2))
An axis is defined between point 1 and point 2.
{Point 1 Point 2}
An axis is defined between point 1 and point 2.
{Point 1 2}
An axis is defined between point 1 and point 2.
Make 2PointAxis (Ev Geo (S1.2.1)) (Ev Geo (G2))
An axis is defined between the 1st vertex of the 2nd edge of surface 1 and point 2.
{S1.1.1 G2}
An axis is defined between the 1st vertex of the 2nd edge of surface 1 and point 2.
Co 2PointAxis (Eval GeometryDef (Solid 1.2.3.1)) (Evaluate GeometryDefinition (Point 4))
An axis is defined between the 1st vertex of the 3rd edge of the 2nd face of solid 1 and point 4.
{Solid 1.2.3.1 Point 4}
An axis is defined between the 1st vertex of the 3rd edge of the 2nd face of solid 1 and point 4.
Defining a vector by referring to a coordinate frame
One way of defining a vector in Patran is to use an axis of a coordinate frame. The selection mechanism can guide you through filtering for picking only coordinate frames, and then using either the 1st, 2nd, or 3rd axis component of the selected coordinate frame as the axis of choice. A vector so constructed uses the origin of the coordinate frame as the base of the vector, and defines the tip using the direction cosines of the transformation matrix.
<coordinateFrameVector>
::=
<coordinateFrameKW> <coordinateFrameLabel> . <coordainateFrameAxisNumber>
<coordinateFrameKW>
::=
CoordinateFrame | Coord | Cord | CF | Frame | Fr | F
<coordinateFrameLabel>
::=
<int> 
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<coordinateFrameAxisNumber>
::=
1 | 2 | 3
 
Table D‑28
List Processor Syntax
Meaning
Coord 0.2
The y axis of coordinate frame 0.
Coord 1.3
The z axis of coordinate frame 1.
Coord 10.1
The x axis of coordinate frame 10.
Defining a vector by referencing two points
Another way of defining a vector in Patran is to define the base and tip of the vector to be constructed through the selection mechanism. Since the selection process uses the full power of the Patran selection mechanism and list processor, points may be defined with arbitrary complexity, such as the intersection of two lines being the base of an axis with the closest approach of a point to a surface being the tip.
 
<2PointVectorExpression>
::=
<constructKW> <2PointVectorKW> <pointGeometryExpression> <pointGeometryExpression>
constructKW
::=
Construct | Co | Make
<2PointVectorKW>
::=
2PointVector
<pointGeometryExpression>
::=
( <evalKW> <geometryDefinitionKW> ( <pointExpression> ) )
<evalKW>
::=
Evaluate | Eval | Ev
<geometryDefinitionKW>
::=
GeometryDefinition | GeometryDef | GeoDefinition | GeoDef | Geometry | Geo
<pointExpression>
::=
<pointInDatebaseExpression> | <pointConstructionExpression>
<pointInDatabaseExpression>
::=
<pointByDatabaseLabelExpression> | <curveVertexExpression> | <surfaceVertexExpression> | <solidVertexExpression>
<pointByDatabaseLabelExpression>
::=
<pointKW> <pointLabel>
<pointKW>
::=
Point | Pnt | Pt | P | grid# | Gr | G
<pointLabel>
::=
<int>
<int>
::=
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<curveVertexExpression>
::=
<curveKW> <curveLabel>.<curveVertex>
<curveKW>
::=
Curve | Crv | C | Line | Li | L
<curveLabel>
::=
<int>
<curveVertex>
::=
<int>
<surfaceVertexExpression>
::=
<surfaceKW> <surfaceLabel>.<surfaceEdge>.<surfaceEdgeVertex>
<surfaceKW>
::=
Surface | Surf | Srf | S | Patch | Pa | P 
<surfaceLabel
::=
<int>
<surfaceEdge>
::=
<int>
<surfaceEdgeVertex>
::=
<int>
<solidVertexExpression>
::=
<solidKW> <solidLabel>.<solidFace>.<solidFaceEdge>.<solidFaceEdgeVertex>
<solidKW>
::=
Solid | Sld | Sl | Hyperpatch | Hpat | Hp| H
<solidLabel>
::=
<int>
<solidFace>
::=
<int>
<solidFaceEdge>
::=
<int>
<solidFaceEdgeVertex>
::=
<int>
<pointConstructionExpression>
::=
<2CurvePointExpression> | <pointCurvePointExpression> | <pointSurfacePointExpression> | <curveSurfacePointExpression>
 
Note:  
The syntax for <2CurvePointExpression>, <pointCurvePoint>, <pointSurfacePointExpression>, and <curveSurfacePoint> may be found under the appropriate headings in this section.
 
Table D‑29
List Processor Syntax
Meaning
Construct 2PointVector (Evaluate Geo ([0 0 0])) (Evaluate Geo ([0 0 1]))
A vector is defined between [0 0 0] and [0 0 1].
Construct 2PointVector (Evaluate Geo (Point 1)) (Evaluate Geo (Point 2))
A vector is defined between point 1 and point 2.
Make 2PointVector (Ev Geo (S1.2.1)) (Ev Geo (G2))
A vector is defined between the 1st vertex of the 2nd edge of surface 1 and point 2.
Co 2PointVector (Eval GeometryDef (Solid 1.2.3.1)) (Evaluate GeometryDefinition (Point 4))
A vector is defined between the 1st vertex of the 3rd edge of the 2nd face of solid 1 and point 4.
Defining a vector by referring to three displacements
Another way of defining a vector in Patran is to define the x, y and z displacements which comprise the vector.
 
<vectorByDisplacementExpression>
::=
< <xDisplacement> <yDisplacement> <zDisplacement>>
<xDisplacement>
::=
<float> 
<yDisplacement>
::=
<float> 
<zDisplacement>
::=
<float> 
<float>
::=
{ <int> } 0:1 { . } 0:1 { <int> } 0:1 { e <int> } 0:1 
<pointLabel>
::=
<int>
<nodeLabel>
::=
<int>
<int>
::= 
{ + | - } 0:1 { <digit> } 1:n
<digit>
::=
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
 
Table D‑30
List Processor Syntax
Meaning
<1 2 3>
A vector with displacements of x = 1, y = 2, z = 3.
<1 0 0>
A vector with displacements of x = 1, y = 0, z = 0.
<2.0000 1.0 3>
A vector with displacements of x = 2, y = 1, z = 3.