Relations: Relation Types

Introduction to Pro/ENGINEER: Relations http://silverstone.fortunecity.com/daytona/344/proehelp/fundamentals/rela...
Web hosting Custom Email SiteBuilder
Contents Book Index Books Products Master Index Search Print Customer Service About Help Home
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
1 of 36 4/16/2011 10:42 PM
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:
d#--Dimensions in Part or Assembly mode.
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 .
rd#--Reference dimensions in part or top-level assembly.
rd#:#--Reference dimensions in Assembly mode. (The assembly or component's session ID number

is added as a suffix.)
rsd#--Reference dimensions in sketcher (section).
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.
tpm#--Tolerance in plus-minus symmetrical format; # is the dimension number.
tp#--Positive tolerance in plus-minus format; # is the dimension number.
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.
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.
2 of 36 4/16/2011 10:42 PM
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 Value = 3.14159

constant)
(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
3 of 36 4/16/2011 10:42 PM
^ 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 `èqual to'' assignment operator is different from the `èqual 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
4 of 36 4/16/2011 10:42 PM
<= 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
5 of 36 4/16/2011 10:42 PM
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
6 of 36 4/16/2011 10:42 PM
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.
7 of 36 4/16/2011 10:42 PM
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(`àsm_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
8 of 36 4/16/2011 10:42 PM
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.
9 of 36 4/16/2011 10:42 PM
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:
10 of 36 4/16/2011 10:42 PM
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:
11 of 36 4/16/2011 10:42 PM
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.
12 of 36 4/16/2011 10:42 PM
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, Extracts pieces of strings.

length)
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.
13 of 36 4/16/2011 10:42 PM
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 re-dimensioned, 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
14 of 36 4/16/2011 10:42 PM
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)
15 of 36 4/16/2011 10:42 PM
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.
16 of 36 4/16/2011 10:42 PM
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:
Current--By default, the top-level assembly.
17 of 36 4/16/2011 10:42 PM
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.
18 of 36 4/16/2011 10:42 PM
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:
Dimensions in the part (d#)
User parameters in the part (parameter_name)
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:
Reference dimensions from the part (rd#)
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:
19 of 36 4/16/2011 10:42 PM
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
/* `àngle: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
20 of 36 4/16/2011 10:42 PM
-------------------- ------- ---------------
PARAM_PART_1 Local 1.234000e+00
PARAM_PART_ANGLE1 Local 9.000000e+01
PARAM_SECT_1 Local 5.500000e+00
Creating Relations in Features

When you create relations in a feature, they are saved with the feature, and stay with it regardless of the model
in which the feature is used. Feature relations are regenerated before part regeneration. Hence, if a relation
performs geometry evaluation (such as the distance between two points), it can give different results if used as a
feature relation versus being used as a part relation.
You can use the same rules in creating relations in features that you use in creating relations in parts and
assemblies.
Note:
New parameters are created in the feature, but you can modify existing model parameters by name from
the feature level.
The following figure shows a typical Show Rel information window for one of the features in the part in the
preceding figure.
Feature Relations for a Part
-------- --------- --- -----
/*** Relations for BRICK feature id = 282:
param_feat2_x = 6.666 param_feat2_x 6.666000e+00
param_feat2_yy = param_feat1_1:FID_1
21 of 36 4/16/2011 10:42 PM
param_feat2_yy 4.567000e+00
param_feat2_xy:FID_1 = param_feat2_x
param_feat2_xy:FID_1 6.666000e+00
/*
DEPTH = 2*param_feat2_x DEPTH 1.333200e+01
/*** Relations for feature id 282, section 1:
sd1 = 2*sd0 sd1 (D32) 1.100000e+01
/*
Symbolic constant X-refs Current value
----------------- ------ ------- -----
PARAM_FEAT_X Local 6.666000e+00
PARAM_FEAT2_YY Local 4.567000e+00
PARAM_FEAT2_X Local 6.666000e+00
22 of 36 4/16/2011 10:42 PM
Creating Relations in Patterns

For a detailed description of relations in patterns, see Pattern Increment Relations in Patterning Features in the
Part Modeling User's Guide.
Creating Relations in Assemblies

You can use the same rules for creating relations in assemblies that you use for creating relations in parts. If the
dimension symbols do not contain a session ID, it is understood that all driven and driving parameters are in the
selected model (top assembly or component). If you want to specify a variable in another model, you must
include that model's Session ID as a suffix in the dimension symbols.
The following figure shows some typical relations for the assembly model tree shown in Typical Assembly Tree.
Some Assembly Relations for the Assembly in Typical Assembly Tree
Relations in Assemblies
When an assembly is created or brought into session, each unique model (whether a top assembly, subassembly,
or part) is assigned its own Session ID.
If a model is used more than once in an assembly, each occurrence of the model has a unique Component
Number and Component ID (which relate to its parent assembly), but all occurrences of the model have the
same Session ID, no matter where they are in the assembly tree.
Different instances of a table-driven model have different Session IDs. As long as a model is in session, it retains
the same Session ID, even if it is used in different assemblies.
23 of 36 4/16/2011 10:42 PM
If an assembly has relations that refer to components (or even the top assembly), the Session IDs for those
components are displayed (under the heading ``Session ID'') above the relations when you choose the Show Rel
command.
Notes:
In an assembly, the following terms are equivalent for components:
Component Number = Feature Number (because components are features of their parent
assemblies).
Component ID = Feature ID (for the same reason).
Do not confuse Session IDs with Component/Feature Numbers or Component/Feature IDs.
For more information, see Assembly Relations in the Assembly Modeling User's Guide.
The following figure shows the model tree for an assembly TEST_ASSY. Note the following points about the
assembly:
Parts BASEPLATE and BASEPLATE_1 each occur twice, but each part has only one Session ID.
Parts BASEPLATE and BASEPLATE_1 are instances of the same part but have different Session IDs.
Typical Assembly Tree
24 of 36 4/16/2011 10:42 PM
Note that in Typical Assembly Tree (a), Subassembly BASE_ASSY.ASM has Feature #1 and Feature ID 1.
Those numbers reflect its membership in its parent assembly, TEST_ASSY.ASM.
However, in Typical Assembly Tree (b), Part BASEPLATE.PRT also has Feature # 1 and Feature ID 1. Those
numbers reflect its membership in its parent assembly, BASE_ASSY.ASM.
The following example lists the Session IDs assigned to the components during one particular session.
Typical Session IDs for Models in Typical Assembly Tree
Model Session ID
TEST_ASSY.ASM 1
25 of 36 4/16/2011 10:42 PM
BASE_ASSY.ASM 3
BASEPLATE.PRT 6
BUSHING.PRT 2
SNAPRING.PRT 4
BASEPLATE_1.PRT 8
Determining a Model's Session ID

To determine a model's Session ID in Assembly mode, do one of the following:
Choose Session Id from the RELATIONS menu and select the model. The model's name and its Session
ID appear in the message window.
Choose Done from the RELATIONS menu. Choose Modify, then select a feature in the model. The
feature's dimensions are displayed in the format d#:session_id (for example, d7:12).
Specifying a Parameter in Another Model

When a parameter belongs to a model (assembly or component) other than the one currently selected, the
parameter must include that model's Session ID (the Session ID is optional for parameters in the current model).
The format for assembly relations is as follows:
XYZ = parameter_name:session_id
where XYZ is a parameter in the currently selected model, parameter_name is a parameter in the referenced
model, and session_id is the referenced model's Session ID.
In the general case, you can express the preceding relations as follows:
XYZ:session_id_1 = parameter_name:session_id_2
where session_id_1 is the Session ID of the driven parameter's model and session_id_2 is the Session ID of the
driving parameter's model.
Tip: Using Internal Component IDs in Assembly Relations
26 of 36 4/16/2011 10:42 PM
If you create an assembly in which the same generic is assembled twice, a relation for the summation of the
lengths of these two components added together could be written:
Total_length = d3:2 + d3:2
where d3 is the dimension and 2 is the Session ID of the generic.
This relation will not accurately calculate the summation of the lengths of the two components if one of the
generics is replaced with an instance from its family table.With the assembly now having one generic part and
one instance, the relation should be updated to:
Total_length = d3:4 + d3:4
where d3 is the dimension and 4 is the Session ID of the instance that replaced the generic.
Pro/ENGINEER cannot distinguish which dimension, of the two dimensions, should be updated to reflect the
Session ID of the instance; if both dimensions should be updated; or if neither should be updated.
To address this situation, you can write assembly relations using internal component IDs (cid). Every component
in an assembly has a unique component ID, even if two component have the same component name (and
therefore the same Session ID). To determine the component ID of a component in the assembly, you can:
Select Info > Component ... >
Select a component.
Click APPLY in the component constraints dialog (the window will display component information
including the component ID).
In an assembly, the model tree displays the FeatID (feature ID) of each assembly component. Remember that in
assemblies, component ID = feature ID because components are features of an assembly. Refer to the figure on
p age 11-28 (Typical Assembly Tree) which shows an example of a model tree diplaying their FeatID
(component ID) of top level components and features.
Using the previous example, the assembly relation for two identical generic components could then be written:
Total_length = d3:cid_1 + d3:cid_3
where d3 is the dimension and cid_1 refers to the first generic component (component id_1 and cid_3 refers to
the other generic component.
If one of the generic components is replaced with one of its instances, the relation will properly be updated to
reflect this change and the total_length will equal the summation of the lenghts of the generic component and the
instance component.
Note:
The proper syntax is:
d#:cid_(component ID #)
Creating Relations in Sections

When you create relations in a section, the relation represents relationships among section entities that do not
27 of 36 4/16/2011 10:42 PM
depend on the feature to which the section belongs. As with feature relations, section relations are saved with the
section. Use section relations when you want to maintain those relationships in the section regardless of where
the section is used.
The following rules apply to creating or modifying relations in sections:
Driven variables can be as follows:
Dimensions in the section (sd#) or in the parent model (d#)
In Assembly mode, dimensions in another model (d#:#)
User parameters in the parent model only (no session-ID suffix allowed).
Driving variables can be as follows:
Dimensions in the section (sd#, rsd#, or kd#), parent model (d#, rd#), or other model in an assembly
(d#:#, rd#:#).
User parameters in the parent model only (no session-ID suffix allowed).
However, relations defining dimensions other than section dimensions are best defined at the feature or
model level.
You cannot directly gain access to a parameter in another feature as a driving variable. For example, if
dia was a dimension in another feature with fid_20, the system would not accept the section relationship
sd3 = dia:fid_20
You can establish the same relationship, however, at the feature level or model level, using the
model-level equivalent (d#) of the section dimension (sd#). Alternatively, you can create an intermediate
user parameter in the parent model, to which you can then gain access from the section. For more
information, see Typical Part Relations Displayed by Show Rel Command.
The following figure shows a typical Show Rel information window for one of the sections in the part in the
figure Typical Part Relations Displayed by Show Rel Command.
Section Relations for a Part
-------- --------- --- -----
/*** Relations for section:
sd1 = 2*sd0 sd1 (D32) 1.100000e+01
28 of 36 4/16/2011 10:42 PM
/*
Note:
If you try to assign a relation outside the section to a parameter that is already driven by another relation
in the section, you get an error message when the system regenerates the model. The same applies if you
try to assign relations in a section to a parameter that is already being driven by a relation outside the
section. Remove one of the relations and regenerate.
For more information, see Adding Relations to Sections in the chapter Sketcher in the Part Modeling User's
Guide.
Specifying User Parameters in Sections

At the section level (Sketcher mode), user parameters can be created only through relations (the Add Param
command is not available). The user parameters are evaluated and stored in the parent model, where they can be
accessed like any other model parameter (they are not accessible, however, through the section's parent feature).
You can also assign relations in a section to user parameters in the parent model.
If you choose Show Rel for the parent model, the Information Window displays the relations in that model's top
level and in the feature sections (but not at the Feature level) and it lists the user parameters under the heading
``Symbolic constant.'' It does not make any distinction between parameters created at the model level and those
created at the section level. The parameters are listed in the order in which they were created.
You can modify or use user parameters from the parent model in section relations. You can assign values to the
same parameter in several sections. After regeneration, the parameter has the value of the last relation to be
evaluated.
Note:
If you try to assign a relation outside the section to a parameter that is already driven by another relation
in the section, you get an error message when the system regenerates the model. The same applies if you
try to assign relations in a section to a parameter that is already being driven by a relation outside the
section. Remove one of the relations and regenerate.
Evaluate Features
In Part and Assembly modes, and in the Pro/NC, Pro/MOLDESIGN, and Pro/DIEFACE modules, the Evaluate
command on the DATUM menu is used to create an Evaluate feature. For more information, see Creating an
Evaluate Feature in the Part Modeling User's Guide. The Evaluate feature is used to create features that are
dependent on the measurement parameters through the use of relations.
Use the following format to gain access to measurement values in the same model (part or assembly):
XYZ = measurement_name:fid_N
29 of 36 4/16/2011 10:42 PM
or
XYZ = measurement_name:fid_feature_name
where measurement_name is the name of the measurement within the Evaluate feature, feature_name is the
name of the Evaluate feature, and N is the internal feature ID number.
Note:
Pro/ENGINEER always converts the feature ID number to the Evaluate feature name; thus, your relations
will use the feature name.
In Assembly mode, use the following format to gain access to measurement values in another model (assembly
or component):
XYZ = measurement_name:fid_N:session_id
or
XYZ = measurement_name:fid_feature_name:session_id
where session_id is the referenced model's session ID.
System Parameters
Mass Property Parameters
The following system parameters are used to determine the mass properties of a part or assembly within a
relation:
mp_mass (``path'') for mass
mp_volume (``path'') for volume
mp_surf_area (``path'') for surface area
mp_cg_x (``path'', ``coord_sys'', ``path'') for x-coordinate of center of gravity
mp_cg_y (``path'', ``coord_sys'', ``path'') for y-coordinate of center of gravity
30 of 36 4/16/2011 10:42 PM
mp_cg_z (``path'', ``coord_sys'', ``path'') for z-coordinate of center of gravity
where
path is the path down to the component along the assembly tree from the current (selected) model. The
path can be specified using component IDs or names with the appropriate extensions (.asm or .prt).
Successive components in the path are separated by colons (:). The whole path must be enclosed in double
quotation marks.
For example, you can enter [``CAP.ASM:PLATE.PRT''] or [``7:6'']. The latter method is required when
more than one part with the same name is included in the assembly. If you access relations while in the
same part (or assembly) for which you want to calculate mass properties, you need not enter the path. (To
specify the current component, enter [``''].)
coord_sys is the coordinate system used to calculate the center of gravity. Enter the name of the
coordinate system (for example [`ÀSCO'']). The name must be in double quotation marks.
path, coor_sys, path are the three arguments required to calculate the center of gravity. For more
information, see the following diagram. Arguments are separated by commas; each argument must be
enclosed in double quotation marks.
When you use these functions with relations, you can:
Find the value of the required mass property using the appropriate function.
Include a desired function in a relation by editing an existing relation or adding a new one.
For example:
a = b + mp_cg_x (``'', ``CS0'', ``'').
Mass Property Parameter--Center of Gravity
The following figure shows examples of the usage of the mass property functions.
Uses of Mass Property Functions
31 of 36 4/16/2011 10:42 PM
Density of Material
You can use the system parameter mp_density in a relation to specify the density of a part. This density value is
used for calculating mass properties. If you change the material density in a part, the system updates the
mp_density value in relations.
If mp_density is being driven by a relation and you change the relation, the density of the part is updated to the
new mp_density when the part is regenerated. In addition, if a material was assigned to the part at the time of
regeneration, the material density is also updated to the new mp_density.
If you change the density of the part using the Density command from the SETUP menu, mp_density is updated
immediately. If a material has been assigned to the part, the material's density is also updated immediately.
If a material has been assigned to the part and you change the density of the assigned material using Material >
Edit, the density of the part and mp_density are both updated immediately.
In both of theses cases, any values that are dependent on mp_density are updated after regeneration.
Use either Add or Edit from the RELATIONS menu to include mp_density in relations.
In an assembly, you can see the density of a particular component part by appending the part's Session ID as
follows:
mp_density: session_id
You can determine the Session ID of a particular component by choosing Component ID from the RELATIONS
menu, then selecting the component from the model or through the menu structure.
For example, in a part:
Specify the density value
32 of 36 4/16/2011 10:42 PM
mp_density = 1.2
Assign the density value to a parameter
J = mp_density
For example, in an assembly:
Change the density value of a specified part:
mp_density:2 = 4.5
Assign the density value of a specified part to a parameter:
K = mp_density:2
Material Parameters
You can use the function material_param (``PARAMETER,'' ``MATERIAL'') in a relation to specify a material
parameter of a solid model. You can update a material parameter in this way, or use the parameter as an
independent variable in a relation.
You can use this function only for materials that are in the model's internal database. If you omit the second
argument entirely, the system assumes that you are referring to the material assigned to the model. (If you have
not yet assigned a material, the system rejects the relation with an appropriate error message.)
The function name must be lowercase and the arguments must be uppercase.
In an assembly, you can see the material parameter of a particular component by including the component's
Session ID as follows:
material_param: session_ID(``PARAMETER'' ``MATERIAL'')
You can determine the Session ID of a particular component by choosing Component ID from the RELATIONS
menu, then picking the component from the model or through the menu structure.
The material parameters that you can specify are as follows:
YOUNG_MODULUS
POISSON_RATIO
SHEAR_MODULUS
MASS_DENSITY
THERMAL_EXPANSION_COEFFICIENT
THERM_EXPANSION_REF_TEMPERATURE
STRUCTURAL_DAMPING_COEFFICIENT
STRESS_LIMIT_FOR_TENSION
STRESS_LIMIT_FOR_COMPRESSION
33 of 36 4/16/2011 10:42 PM
STRESS_LIMIT_FOR_SHEAR
THERMAL_CONDUCTIVITY
EMISSIVITY
SPECIFIC_HEAT
HARDNESS
CONDITION
INITIAL_BEND_Y_FACTOR
BEND_TABLE
If the function material_param() is being driven by a relation and you change the relation, the specified
material parameter is updated after regeneration. If it is used as a driving variable and you change it, the driven
variable or dimension, likewise, is updated after regeneration.
For example, in a part:
Assign a value to the parameter HARDNESS in the material STEELA. The material must be in the part's
internal database (but is not necessarily assigned to the part):
material_param(``HARDNESS'', ``STEELA'') = 0.05
Assign a value to the parameter POISSON_RATIO in the assigned material:
material_param(``POISSON_RATIO'') = 0.30
Make a dimension dependent on the assigned material parameter YOUNG_MODULUS:
d12 = material_param(``YOUNG_MODULUS'')/1000
For example, in an assembly:
Assign a value to the assigned material parameter POISSON_RATIO in the component with Session ID
10:
material_param:10(``POISSON_RATIO'') = 0.30
Make dimension d17 dependent on the assigned material parameter HARDNESS in the component with
session ID 21:
d17 = material_param:21(``HARDNESS'')*40
If a driven dimension is a function of a material parameter, and that material parameter is replaced later by a
parameter with no value (for example, by assigning to the part another material, which has no value assigned to
that parameter), the driven symbol retains its last correct value.
User Parameters
User parameters can be added and stored with a model without having to be defined in a relation. These are ideal
34 of 36 4/16/2011 10:42 PM
for providing additional information, for example, in family tables in which the parameter Cost might have a
different value for each instance. They can be added at the model level (part, assembly, or component) or to a
feature or pattern.
You can also add user parameters to features and patterns, or to surfaces or edges, by choosing Parameters
from the SETUP menu.
Adding Parameters
With the Add Param command, you can add a user parameter name and value for future use or reference. This
option is also used for adding global parameters used in layouts. For more information, see the chapter Layouts
in the Assembly Modeling Users' Guide.
How to Add a User Parameter to the Model
1. Choose RELATIONS > Add Param.
2. From the ADD PARAM menu, choose one of the following commands:
Integer--Add an integer number parameter to the model.
Real Number--Add a decimal number parameter to the model.
String--Add a string parameter to the model.
Yes No--This string-type parameter uses only the values yes, no, true, and false. It may be included
in family tables.
Note--Use the note parameter to include model notes in family tables and lists of relations. The
value of a note parameter is the ID of a model note. The parameter can be included in a family
table, with different instances using different notes present in the generic. In addition, whenever you
show relations for the model, all note parameters are listed, including their ID and textual content.
3. Enter the new parameter name and value.
Repeat as often as you want. The parameters added with Add Param appear in a listing of the relations for the
models.
Modifying Parameters
A user parameter that has been added using Add Param can be modified through the ASSEM SETUP or PART
SETUP menu. If a parameter is included in a family table, layout note, or relation, it can also be modified by
editing that family table, note, or relation.
Deleting Parameters
Deleting a relation that defines a user parameter does not delete the parameter itself.
How to Delete a User Parameter from the Model
1. Choose RELATIONS > Del Param
35 of 36 4/16/2011 10:42 PM
or
Choose MODEL PARAMS > Delete (MODEL PARAMS is available through the ASSEM SETUP or
PART SETUP menu). The PARAMETER menu appears.
2. From the PARAMETER menu, select the parameter name.
3. Choose Done.
You cannot delete a user parameter that is driven by a relation or used in a relation. You must first delete the
relation(s) in which it is used, then follow the preceding procedure to remove the parameter.
Designating Parameters
You can designate selected system and user parameters for use as attributes in Pro/PDM or in Pro/INTRALINK.
For more information, see the Pro/INTRALINK 1.0 User's Guide.
Contents Book Index Books Products Master Index Search Print Customer Service About Help Home
Copyright © 1998 Parametric Technology Corporation

128 Technology Drive, Waltham, MA 02154 USA
All rights reserved
web hosting • domain names

web design • online games
36 of 36 4/16/2011 10:42 PM
��
��
��

Relations: Relation Types

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Relations: Relation Types

Uploaded by

Copyright:

Available Formats

Introduction to Pro/ENGINEER: Relations http://silverstone.fortunecity.com/daytona/344/proehelp/fundamentals/rela...

Web hosting Custom Email SiteBuilder

There are two types of relations:

Simple assignment: d1 = 4.75

More complex assignment: d5 = d2*(SQRT(d7/3.0+d4))

As a constraint: (d1 + d2) > (d3 + 2.5)

In a conditional statement: IF (d1 + 2.5) >= d7

Dimension symbols--The following dimension symbol types are supported:

d#--Dimensions in Part or Assembly mode.

d#:#--Dimensions in Assembly mode. The assembly or component's session ID number is added as a

rd#--Reference dimensions in part or top-level assembly.

rd#:#--Reference dimensions in Assembly mode. (The assembly or component's session ID number

rsd#--Reference dimensions in sketcher (section).

kd#--Known dimensions (in parent part or assembly) in sketch (section).

tpm#--Tolerance in plus-minus symmetrical format; # is the dimension number.

tp#--Positive tolerance in plus-minus format; # is the dimension number.

tm#--Negative tolerance in plus-minus format; # is the dimension number.

p#--Where # is the number of instances.

User Parameters--These can be parameters defined by adding a parameter or a relation:

User parameter names cannot contain nonalphanumeric characters such as !, @, #, and $.

The following parameters are reserved for use by the system:

PI (geometric Value = 3.14159

G (gravitational constant) Default value = 9.8 meters/sec2

Operators and Functions

() Parentheses for grouping

The following comparison operators are supported:

> Greater than

>= Greater than or equal to

!=, <>,~= Not equal to

< Less than

<= Less than or equal to

d1 > 2 & d1 < 3 & d1 ~= 2.5

sqrt () square root

asin () arc sine

acos () arc cosine

atan () arc tangent

sinh () hyperbolic sine

cosh () hyperbolic cosine

tanh () hyperbolic tangent

All trigonometric functions use degrees.

log() base 10 logarithm

ln() natural logarithm

exp() e to an exponential degree

abs() absolute value

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:

will function as in previous releases, if not specified.

ceil (10.2) evaluates to 11

ceil (10.255, 2) evaluates to 10.26

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:

Note that the ( ) are empty.

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

Tip: Comments in Relations

How to Determine the Value of an Expression

1. Choose RELATIONS > Evaluate.

Use the Add command from the RELATIONS menu.

Edit the relations file and add more relations.

Relations are not evaluated until the model is regenerated.