Web hosting

Custom Email

SiteBuilder

Relations
Relations (also known as parametric relations) are user-defined equations written between symbolic dimensions and parameters. Relations capture design relationships within features or parts, or among assembly components, thereby allowing users to control the effects of modifications on models. Topic Relations Basics Adding Relations Modifying Relations Viewing Relations Sorting Relations Selecting the Model or Feature Specifying a Feature and Model in a Relation Creating Relations in Parts Creating Relations in Features Creating Relations in Patterns Creating Relations in Assemblies Creating Relations in Sections System Parameters User Parameters

Relations Basics
Relations are a way of capturing design knowledge and intent. Like parameters, they are used to drive models--change the relation and you change the model. Relations can be used to control the effects of modifications on models, to define values for dimensions in parts and assemblies, and to act as constraints for design conditions (for example, specifying the location of a hole in relation to the edge of a part). They are used in the design process to describe conditional

relationships between different parts of a model or assembly. Relations can be simple values (for example, d1=4) or complex conditional branching statements.

Relation Types
There are two types of relations:

Equality--Equates a parameter on the left side of the equation with an expression on the right side. This type of relation is used for assigning values to dimensions and parameters. For example: Simple assignment: d1 = 4.75 More complex assignment: d5 = d2*(SQRT(d7/3.0+d4))

Comparison--Compares an expression on the left side of the equation with an expression on the right side. This type of relation is commonly used as a constraint or in conditional statements for logical branching. For example: As a constraint: (d1 + d2) > (d3 + 2.5) In a conditional statement: IF (d1 + 2.5) >= d7

Parameter Symbols
There are four types of parameter symbols used in relations:

Dimension symbols--The following dimension symbol types are supported: o d#--Dimensions in Part or Assembly mode. o d#:#--Dimensions in Assembly mode. The assembly or component's session ID number is added as a suffix. For more information, see Creating Relations in Features . o rd#--Reference dimensions in part or top-level assembly. o rd#:#--Reference dimensions in Assembly mode. (The assembly or component's session ID number is added as a suffix.) o rsd#--Reference dimensions in sketcher (section). o kd#--Known dimensions (in parent part or assembly) in sketch (section). Tolerances--These are parameters associated with tolerance formats. These symbols appear when dimensions are switched from numeric to symbolic. o tpm#--Tolerance in plus-minus symmetrical format; # is the dimension number. o tp#--Positive tolerance in plus-minus format; # is the dimension number. o tm#--Negative tolerance in plus-minus format; # is the dimension number. Number of Instances--These are integer parameters for the number of instances in a direction of a pattern. o p#--Where # is the number of instances.

Note:

If you change the instance number to a non-integer value, Pro/ENGINEER truncates it. For example, 2.90 becomes 2.

User Parameters--These can be parameters defined by adding a parameter or a relation: For example:
Volume = d0*d1*d2 Vendor = ``Stockton Corp.''

Notes:

User parameter names must begin with a letter if they are to be used in relations. You cannot use d#, kd#, rd#, tm#, tp#, or tpm# as user parameter names, because they are reserved for use with dimensions: User parameter names cannot contain nonalphanumeric characters such as !, @, #, and $.

The following parameters are reserved for use by the system:

PI (geometric constant)

Value = 3.14159 (You cannot change this value.)

G (gravitational constant)

Default value = 9.8 meters/sec2 (C1, C2, C3, and C4 are default values and equal 1.0, 2.0, 3.0, and 4.0, respectively.)

You can change the values of these system parameters using the Add command from the RELATIONS menu. The changed values are then used in all models for the current session.

Operators and Functions

The following operators and functions can be used in relations--both in equations and in conditional statements.

Arithmetic Operators

Addition

Subtraction

Division

Multiplication

Exponentiation

()

Parentheses for grouping for example, d0 = (d1-d2)*d3

Assignment Operator

Equal to

The = sign is an assignment operator that equates the two sides of an equation or relation. When it is used, the equation can have only a single parameter on the left side. Note: The ``equal to'' assignment operator is different from the ``equal to'' comparison operator. For more information, see Comparison Operators.

Comparison Operators
Comparison operators are used whenever a TRUE/FALSE value can be returned. For example, the following relation returns TRUE whenever d1 is greater than or equal to 3.5. It returns FALSE whenever d1 is less than 3.5:
d1 >= 3.5

The following comparison operators are supported:

==

Equal to

>

Greater than

>=

Greater than or equal to

!=, <>,~=

Not equal to

<

Less than

<=

Less than or equal to

Or

&

And

~, !

Not

The operators|, &, !, and ~ extend the use of comparison relations by enabling several conditions to be set in a single statement. For example, the following relation returns TRUE whenever d1 is between 2 and 3, but not equal to 2.5:
d1 > 2 & d1 < 3 & d1 ~= 2.5

Mathematical Functions
Relations may also include the following mathematical functions:

cos ()

cosine

tan ()

tangent

sin ()

sine

sqrt ()

square root

asin ()

arc sine

acos ()

arc cosine

atan ()

arc tangent

sinh ()

hyperbolic sine

cosh ()

hyperbolic cosine

tanh ()

hyperbolic tangent

Note: All trigonometric functions use degrees.

log()

base 10 logarithm

ln()

natural logarithm

exp()

e to an exponential degree

abs()

absolute value

ceil()

the smallest integer not less than the real value

floor()

the largest integer not greater than the real value

You can add an optional argument to both the ceil and the floor functions that allows you to specify a number of decimal places for rounding.

The syntax for these functions, with the rounding parameter, is:
ceil (parameter_name or number, number_of_dec_places) floor (parameter_name or number, number_of_dec_places)

where number_of_dec_places is an optional value that:

can be represented as a number or as a user-defined parameter. If the parameter value is a real number, it will be truncated to an integer value. has a maximum value of 8. If this value is exceeded, the number being rounded (the first argument) will not be rounded and the initial value will be used. will function as in previous releases, if not specified.

The following examples show ceil and floor used without specifying number of decimal places:
ceil (10.2) evaluates to 11 floor (-10.2) evaluates to -11

The following examples show ceil and floor used with specifying number of decimal places:
ceil (10.255, 2) evaluates to 10.26 ceil (10.255, 0) evaluates to 11 [This is the same as ceil (10.255)] floor (10.255, 1) evaluates to 10.2 floor (-10.255, 2) evaluates to -10.26

Graph Evaluation
Graph evaluation enables you to use graph features to drive dimensions through relations. For more information, see the Part Modeling User's Guide. The dimensions can be sketcher, part, or assembly dimensions. The format is:
evalgraph(``graph_name'', x)

where graph_name is the name of a graph and x is the value along the graph's x-axis for which the y value is returned. See the following figure.

For sweep features, you can specify the trajectory parameter trajpar as the second argument of this function. For more information, see Using Relations in Sweeps in Sweeps, Blends, and Advanced Features in the Part Modeling User's Guide. Note: A graph feature is usually evaluated for its defined x-axis values. When it is evaluated beyond the defined range, the y-axis values are extrapolated. The system calculates the extrapolated value for values of x less than the initial value by extending a tangent line back from the initial point. Likewise, the system calculates the extrapolated value for values of x greater than the final value by extending a tangent line out from the final point.

Composite Curve Trajectory Function

The trajectory parameter of a composite curve, trajpar_of_pnt, can be used in relations. The following function returns a value between 0.0 and 1.0:
trajpar_of_pnt(``trajname'', ``pointname'')

where trajname is the name of a composite curve and pointname is the name of a datum point. The trajectory is a parameter along the composite curve at which the plane, normal to the tangent of the curve, passes through the datum point. Therefore, the datum point does not have to be located on the curve; the parameter is calculated at the point on the curve that is closest to the datum point. If the composite curve is used as the spine of a multi-trajectory sweep, then trajpar_of_pnt either agrees with the parameter trajpar at this plane, or else with 1.0 - trajpar (depending on your choice of starting point for the sweep feature). For more information, see Using Relations in Sweeps in Sweeps, Blends, and Advanced Features in the Part Modeling User's Guide.

Other Functions
The following functions allow you to pass strings as arguments:

string_length()--Returns the number of characters in a parameter. For example, if the value for the string parameter material is defined as steel, string_length(material)

equals 5, because the word ``steel'' has five letters. rel_model_name()--Returns the current model name. For example, if you are currently working in a part called A, rel_model_name() is equal to A. To use this in a relation in an assembly, the relation would look like the following: name = rel_model_name:2() Note that the ( ) are empty.

rel_model_type()--Returns the current model type. If you are working in assembly mode, rel_model_type() is equal to assembly. exists()--Evaluates whether an item, such as a parameter or dimension, exists. This can

apply to the model for which the relation is being evaluated, or to any model, component, or submodel structure. For example:

if exists(d5:20)-- Checks if model with runtime ID 20 has dimension d5 if exists (``par:fid_25:cid_12'')--checks if feature ID 25 in component ID 12 has parameter par

This allows decisions to be based on a parameter that exists in only one part of a large assembly. For example, suppose that there are several systems in a large assembly (such as hydraulic, pneumatic, or electrical systems), but the majority of objects belong to no system. In this case, you only need to assign the appropriate parameter to those models that belong in a system in order to make evaluations that are based on the parameter. For instance, if items in the electrical system need to use a part number in the BOM report table, instead of the model name, you would create a report parameter bom_name and write the following relation:
if exists(``asm_mbr_cabling'') bom_name = part_no else bom_name = asm_mbr_name endif

Comments
Relations can be annotated using comments. Every comment line must begin with a slash and an asterisk. An example of a comment in a relation is:
/* Width is equal to 2*height d1 = 2*d2

The comment should come before the relation to which it applies. Then, when the relation is sorted, the comment moves with it--and stays above it. For more information, see Sorting Relations .

Tip: Comments in Relations

It is good practice to use comments in your relations. By doing so, you will always be able to remember what the relation is and why you used it in the model. Comments will also benefit others who use your models.

Evaluating Expressions
Occasionally, you need to know the value of an expression, either a single parameter or an equation, without having to add it to the model as a relation. How to Determine the Value of an Expression 1. Choose RELATIONS > Evaluate. 2. Enter the parameter symbol (for example, d20, $d20, d10:2, depth), user parameter (for example, volume, color), or expression (for example, d5 + d6, d2!= d4). 3. Press ENTER. The result of the evaluation appears in the message area. Comparison equations, such as d2!= d4 or d3 == d2, return either a 0 (false) or a 1 (true).

Adding Relations
Relations can be added to a model in one of three ways:

Use the Add command from the RELATIONS menu. Edit the relations file and add more relations. Modify a dimension and, when you are prompted for the new value, enter the right side of the relation. For more information, see Modifying Relations.

Adding a Relation
How to Add a Relation to a Model 1. Choose RELATIONS > Add. A prompt and text box appear below the model. 2. Type a relation, and press ENTER. The system accepts the entry and clears the text box. You can type as many relations as desired, pressing ENTER after each one. 3. To finishing adding relations to the model, leave the text box blank and press ENTER. Note: The system does not accept a parameter, variable, or symbol name more than 31 characters long.

Order of Evaluation

Within a given model, relations are evaluated starting with the first relation you entered and ending with the most recent relation you entered. Therefore, if a parameter is driven by two relations, the later relation overrides the earlier one. However, in some cases, relations defined at different levels may conflict. Use the tools available for viewing your relations to make sure that they fulfill your design intent. For more information, see Viewing Relations Note: Relations are not evaluated until the model is regenerated.

Displaying Dimension Symbols

Choosing the Relations command automatically switches the dimension display to symbolic format (for example, d0). If a model's dimensions are not already displayed when you choose Relations, pick the feature or part whose dimensions you want to display. You can switch between symbolic and numeric dimension formats using the Switch Dim command. Note: Symbolic tolerances appear only for dimensions with plus-minus or symmetrical formats. Other format types display only the dimension symbol.

Negative Dimensions
If you are using negative dimensions, and you want to capture the true signed value in your relation, precede the symbol with a dollar sign (for example, $d20 or $depth). This must be done regardless of the setting for the configuration option show_dim_sign. You can use the Show Dim command to display given dimensions in a given model.

Simultaneous Equations
Simultaneous equations are relations in which several variables or dimensions must be solved simultaneously. For example, suppose that you have a box of width d1 and height d2, and that you want to specify the following conditions:

The area equals 100 The perimeter length equals 50

You can enter the following simultaneous equations:

SOLVE d1*d2 = 100 2*(d1+d2) = 50 FOR d1 d2 ...or... FOR d1,d2

All lines between the SOLVE and FOR statements become part of the simultaneous equations. The FOR line lists the variables to be solved. Any variables that appear in the simultaneous

equations but not in the FOR list are interpreted as constants. Thus, you could have entered the following instead:
area = 100 perimeter = 50 SOLVE d1*d2 = area 2*(d1 + d2) = perimeter FOR d1 d2

Variables used in simultaneous equations must be initialized beforehand. For example, omitting area = 100 in the preceding relation would cause an error. Relations defined by simultaneous equations can be freely intermixed with single variable relations. Both are displayed when you select Show Rel, and they can be edited using Edit Rel. Note: Even if there is more than one solution for the system of equations, only one set is returned. You can add extra code downstream from simultaneous equations to specify a solution when there is more than one. For example, in the preceding examples, the two possible sets of solutions are d1=5, d2=20 and d1=20, d2=5. You might want to add the constraint d1 <= d2 by adding the following conditional code:
IF d1 >d2 temp = d1 d1 = d2 d2 = temp ENDIF

For more information, see Conditional Statements.

Conditional Statements
IF Statement
IF statements may be added to relations to form conditional statements. For example:
IF d1 > d2 length = 14.5 ENDIF IF d1 <= d2 length = 7.0 ENDIF

A condition is an expression that is either TRUE (or YES) or FALSE (or NO). These values may be used interchangeably in the conditional statement. For example the following statements can all be evaluated the same way:

IF ANSWER == YES IF ANSWER == TRUE IF ANSWER

ELSE Statement
Even more complex conditional constructions may be achieved by using ELSE statements in the branches. With these statements, the previous relation may be modified to look like the following:
IF d1 > d2 length = 14.5 ELSE length = 7.0 ENDIF

There can be several features listed between the IF, ELSE, and the ENDIF statements. In addition, the IF--ELSE--ENDIF constructions can also be nested within feature sequences that are a model of some other IF--ELSE--ENDIF construction. The syntax of the IF clause is as follows:
IF <condition> Sequence of 0 or more relations or IF clauses ELSE <optional> Sequence of 0 or more relations or IF clauses <optional> ENDIF

Notes:

ENDIF must always be spelled as one word. ELSE must be on a line by itself. Equal in conditional statements must be entered as two equal signs (==). Assignment must be entered as a single equal sign (=).

String Values for Parameters

String values can be entered for parameters. String values are entered between double quotation marks. An example of the use of strings is a reference on a drawing that depends on the size of a feature parameter. The drawing note would use the parameter name within the note, and the model relation would look like this:
IF d1 > d2 MIL_REF = ``MIL-STD XXXXA'' ELSE MIL_REF = ``MIL-STD XXXXB'' ENDIF

Operators and Functions

The following operators and functions are supported for strings:

==

Compares strings as equal.

!=, <>, ~=

Compares strings as unequal.

Concatenates strings.

itos(int)

Converts integers to strings. Here, int can be a number or an expression. Non-integers are rounded off.

search(string, substring)

Searches for substrings. The resulting value is the position of the substring in the string (0 if not found).

extract(string, position, length)

Extracts pieces of strings.

For example: If param = abcdef, then:

flag = param == abcdef--Returns TRUE. flag = abcdef != ghi--Returns TRUE. new = param + ghi--new is abcdefghi. new = itos(10 + 7)--new is 17. new = param + itos(1.5)--new is abcdef2. where = search(param, bcd)--where is 2. where = search(param, bcd)--where is 0. new = extract(param,2,3)--new is bcd.

Modifying Relations
Editing Relations

Relations are stored with the model and may be edited at any time during model creation. Relations can be modified, added, deleted, or commented on at any other time by choosing Edit Rel from the RELATIONS menu. You can use either the system text editor or Pro/TABLE, depending on the editor specified in the configuration file option pro_editor_command. How to Edit a Relation 1. Choose RELATIONS > Edit Rel. If you are using the system editor, a text file appears. If you are using Pro/TABLE, the relations appears in a tabular format. 2. Edit the relations using the appropriate editor commands. If you are editing the relations to correct errors detected by Pro/ENGINEER, delete the error messages after you have corrected the erroneous relations. Pro/ENGINEER does not remove these messages by itself. 3. Exit the editor to return to Pro/ENGINEER. The relations are updated automatically. 4. Regenerate the model to cause the updated relations to change the model. Note: Although you can add relations using the Edit Rel command, this method is not recommended. Choosing Add checks relational input and flags the user with an error message if a relation is incorrect. Relations added using Edit Rel are not checked for errors. If a relation added using Edit Rel is incorrect, it is ignored. You can also check the validity of relations using Show Rel.

Errors in Relations
Pro/ENGINEER checks the validity of relations in a file that has just been edited, and, if it finds errors in the relations file, immediately places you back into edit mode and flags the erroneous relations. You can then correct the flagged relations. Three kinds of error messages can appear in a relations file:

Long line--The relations line has more than 80 characters. Edit the line, or break the relation into two lines by entering a backslash (\) to indicate that the relation continues on the next line. Long sym--A symbol name has more than 31 characters. Edit the symbol name to be less than 31 characters. Error--A parse error occurred; for example, a parameter was not defined. Evaluate the relations for the error and edit accordingly.

Note: Constraint violations are not trapped by this error check. If a simultaneous relation fails to converge, a warning appears in the message area. If an unclosed simultaneous relation is encountered, an error message appears on an empty line after the last relation line.

Modifying Dimensions Driven by Relations

If a dimension is driven by a relation, it cannot be modified directly. If you try to do so, Pro/ENGINEER displays an error message. For example, if the relation d0=d1+d2 is entered, you cannot modify d0 directly. You must modify d1 or d2, or edit the relation in order to change the value of d0. If a dimension symbol is modified, the change is automatically reflected in the relation file.

Obsolete Relations
Whenever a symbol in a relation does not exist anymore because it was deleted or redimensioned, the relation becomes obsolete. The driven symbol retains the last correct value of the dimension. You must manually delete obsolete relations, as they are not automatically deleted by Pro/ENGINEER. To delete an obsolete relation, choose Edit Rel from the RELATIONS menu and edit the relations file appropriately.

Obsolete User Parameters

How to Delete an Obsolete User Parameter 1. Choose RELATIONS > Del Param. The PARAMETER menu appears. 2. From the PARAMETER menu, select the name of the parameter you want to delete. 3. Choose Done.

Viewing Relations
You can view relations without displaying the system editor by choosing Show Rel from the RELATIONS menu. After you choose Show Rel, the relations for the selected item are displayed together with the current values of the driven parameters. Show Rel can also be used to check for the validity of a relation. If you add a relation incorrectly using Edit Rel, and you then choose Show Rel, the invalid relation does not appear in the Information Window. You can then select Edit Rel and correct the error. The Show Rel Information Window is organized as follows:

In a part or assembly--Displays the relations and user parameters created in that model and in its feature sections. It does not list relations or parameters created in its features. In a feature--Displays relations created in that feature and in its sections (if applicable), as well as user parameters created in that feature.

In a pattern--Displays pattern parameters, relations, and user parameters created in that pattern for the selected direction, as well as user parameters and section relations in the parent model. In a section--Displays the relations created in that section only.

User parameters are displayed (under the heading ``Symbolic constant'') with the following information:

Parameter name Cross-reference status--either Local (associated only with a part or assembly) or Global (associated with a project) Number of cross-references if the parameter is global Parameter's current value

Viewing Feature Relations

You can also use Feature from the Info menu to view feature relations. Relations are displayed at the bottom of the list under three headings:

Relations in the feature's section(s) Part relations driven by this feature (actually relations in the parent model, which could be a part or assembly) Feature relations

Sorting Relations
The sort function sorts relations in order of precedence. Whenever you choose Sort Rel from the RELATIONS menu, the relations are ordered so that a relation that depends on the value of another relation is evaluated after that relation. Circular relations are also detected.

Using the Sort Rel Option

If you enter:
d0 = d1 + 3*d2 d2 = d3 + d4

and then choose Sort Rel, the relations look like this:
d2 = d3 + d4 d0 = d1 + 3*d2

because this is the order in which the relations should be evaluated. Note:

If the relations are already in order, they may still be rearranged by the sort utility. They may look scrambled, but the resulting order is valid.

Sorting Simultaneous Equations

Simultaneous equations can be sorted just like normal relations. The set of simultaneous equations is treated as if it were a single relation and is moved around as a unit. This unit is considered to be dependent upon the union of all the quantities its individual lines depend upon. If the simultaneous equation contains additional relations not being solved for, as in the following:
SOLVE d1 + d2 = 500 d55 = d56 + 50 d56 = d54 d1--d2 = 0 FOR d1 d2

the extra lines are sorted within the body of the simultaneous equation, producing:
SOLVE d1 + d2 = 500 d1-d2 = 0 d56 = d54 d55 = d56 + 50 FOR d1 d2

Lines are never inserted into or removed from simultaneous equations.

Sorting Relations with Comment Lines

Relations with comment lines can also be sorted. The comment line is attached to the relation below it, and moves with that relation during a sort. If multiple comment lines precede a relation, they are all attached to that relation.

Circular Relations
Occasionally you may mistakenly create a circular relation, such as the following:
d0 = d1 d1 = d0

Such a set of relations clearly cannot be sorted by order of evaluation. The relation sorter detects such a problem and warns you. However, the preceding lines would be valid parts of a simultaneous equation. It is possible to redefine a symbol in the course of entering relations, as in the following:

d0 = d1 ... d0 = 2*d1

Such constructs are clearly order-dependent and cannot be sorted. The system again warns you.

Conditional Statements
Relations containing conditional statements are not sorted.

Selecting the Model or Feature

Relations can be added to:

A section of a feature (in Sketcher mode when the section is originally created by choosing SKETCHER > Relation > Add). A feature (in Part or Assembly mode). A part (in Part or Assembly mode). An assembly (in Assembly mode).

When you first choose the RELATIONS menu, it is assumed that you want to view or change the relations in the current model (for example, a part in Part mode). To gain access to relations, choose Relations from the PART or ASSEMBLY menu, then select one of the following commands from the MODEL REL menu:

Assem Rel--Gain access to relations in an assembly. For more information, see Assembly Relations in Other Assembly Functions in the Assembly Modeling User's Guide. If the assembly contains one or more subassemblies, the ASSEM REL menu appears with the following commands: o Current--By default, the top-level assembly. o Name--Enter the name of the assembly. Skeltn Rel--Gain access to relations for a skeleton model in the assembly (Assembly only). Part Rel--Gain access to relations in a part. Feat Rel--Gain access to relations specific to a feature. If the feature has a section, you have the choice of gaining access to section (Sketcher) relations in the section (Section) or gaining access to relations in the feature as a whole (Feature). Pattern Rel--Gain access to relations specific to a pattern. Notes:

If you try to assign a relation outside the section to a parameter that is already driven by a section relation, you get an error message when the system regenerates the model. The same applies if you try to assign a relation to a section

parameter that is already driven by a relation outside the section. Remove one of the relations and regenerate. If an assembly tries to assign a value to a dimension variable that is already driven by a part or subassembly relation, two error messages appear. Remove one of the relations and regenerate.

Specifying a Feature and Model in a Relation

You can write relations that use a feature's user parameters and manufacturing parameters. If a parameter is attached to a feature, and you are writing the relation in the same feature, you can identify it simply by name. For example: XYZ = parameter_name where parameter_name is the user parameter. If, however, you are writing the relation in the feature's parent model (part or assembly) or in another feature, you must use one of the following formats to identify it: XYZ = parameter_name:fid_N or XYZ = parameter_name:fid_feature_name where parameter_name is the user parameter for the feature, N is the internal feature ID (as displayed when you use Info, Feat Info), and feature_name is the optional user-defined feature name. In Assembly mode, use the following format to access a user parameter in a feature of another model: XYZ = parameter_name:fid_N:session_id or XYZ = parameter_name:fid_feature_name:session_id where session_id is the model's session ID. For example, suppose that dia is a number-type user parameter in a part feature called CUT_A, CUT_A's internal feature ID is 20, and d5 is a dimension in another feature. You could establish a relationship between d5 and dia in the part as follows:

d5 = dia:fid_20

or
d5 = dia:fid_CUT_A

In an assembly, if the driving parameter was in another model with session ID 12, you could write the relation as follows:
d5 = dia:fid_20:12

or
d5 = dia:fid_CUT_A:12

Creating Relations in Parts

The following rules apply to creating or modifying relations in parts:

Driven variables can be as follows: o Dimensions in the part (d#) o User parameters in the part (parameter_name) o User parameters in features (parameter_name:fid_N or parameter_name:fid_feature_name) Driving variables can be the same as the driven variables described in the preceding list. In addition, you can use: o Reference dimensions from the part (rd#) o Evaluation feature measurements in the following format: measurement_name:fid_N or measurement_name:fid_feature_name Typical Part Relations Displayed by Show Rel Command

RELATION

PARAMETER

NEW VALUE

/*** Relations for BRICK:

param_part_1 = 1.234

param_part_1

1.234000e+00

/*

/* Part parameter 'part_param_part_angle1' is used as

/* a bridge, so that the eval function parameter

/* ``angle:fid_angle1'' can be accessed from a section.

param_part_angle1 = angle:FID_ANGLE1

param_part_angle1

9.000000e+01

/*

param_part_1 = 1.234

param_part_1

1.234000e+00

/*** Relations for feature id 282, section 1:

param_sect_1 = sd0

param_sect_1

5.500000e+00

sd1 = 2*sd0

sd1 (D32)

1.100000e+01

/*

sd3 = 0.03*param_part_angle1

sd3 (D34)

2.700000e+00

Symbolic constant

X-refs

Current value

--------------------

-------

---------------

PARAM_PART_1

Local

1.234000e+00

PARAM_PART_ANGLE1

Local

9.000000e+01

PARAM_SECT_1

Local

5.500000e+00