Relations

Introduction to to Pro/ENGINEER: Relations

http: //silverstone.fortunecity.com/daytona/344/proehelp/fundamentals/rela...

Web hos ting

Custo m E mai l

SiteBui lder

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 Viewi ng Relations Relat ions 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 Relations in Patterns Pat terns Creating Relations in Assemblies Creating Relations in Sections System Parameters User Us er 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 assig a ssignment: nment: 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 conditional statement: IF

(d1 + 2.5) >= d7

Parameter Symbols There are four types of parameter symbols used in relations: Dimension symbols--The following dimension dimension symbol types are supported: suppor ted:

d#--Dimensions in in Part Par t or Assembly Assembly mode. d#:#--Dimensions d#:#--Dimensions in Assembly mode. The assembly or component's session ID number is a dded 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. 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.



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 assig a ssignment: nment: 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 conditional statement: IF

(d1 + 2.5) >= d7

Parameter Symbols There are four types of parameter symbols used in relations: Dimension symbols--The following dimension dimension symbol types are supported: suppor ted:

d#--Dimensions in in Part Par t or Assembly Assembly mode. d#:#--Dimensions d#:#--Dimensions in Assembly mode. The assembly or component's session ID number is a dded 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. 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.

Introduction to Pro/ENGINEER: Relations

http: // //silverstone.fortunecity.com/daytona/344/proehelp/fundamentals/rela...

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

Notes:

User parameter names must begin 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 nonalphanumeric charact ers such as !, @, #, and $. The following parameters are reserved for use by the system:

PI (geometric constant)

Value = 3.14159 (You cannot change chan ge this value.)

G (grav (gravit itati ationa onall const constan ant) t)

Defaul efaultt val value ue = 9.8 9.8 meters eters/s /sec2 ec2 (C1, C2, C3, and C4 are default d efault values and equal 1.0, 2.0, 3.0, and 4.0, respectively.)

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

Operators and Functions The following 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 `è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


<=

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 t hese functions, with the rounding parameter, is: ceil (parameter_name floor (parameter_name

or

number,

or

number,

number_of_dec_places) 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: (10.2) evaluates to 11 floor (-10.2) evaluates to -11 ceil



The following examples show ceil and floor used with specifying number of decimal places: (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 ceil

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 c omposite 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 t he 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 p arameter 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



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 ent ered 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 the preceding relation would cause an error.

area = 100 in

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 Sequence of 0 or more relations or IF clauses ELSE Sequence of 0 or more relations or IF clauses 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 no te, 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 P ro/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 P ro/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 r elations 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 edit the relation in order to change the value of d0.

d0

directly. You must modify d1 or d2, or

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



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: Current --By default, the top-level assembly.



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: 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

/*** Relations for BRICK:

PARAMETER

NEW VALUE



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.234000e+00

/*

param_part_1 = 1.234

/*** 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

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

RELATION

PARAMETER

NEW VALUE

--------

---------

--- -----

/*** Relations for BRICK feature id = 282:

param_feat2_x = 6.666

param_feat2_x

param_feat2_yy = param_feat1_1:FID_1

6.666000e+00



param_feat2_yy

4.567000e+00

param_feat2_xy:FID_1 = param_feat2_x

param_feat2_xy:FID_1

6.666000e+00

DEPTH

1.333200e+01

/*

DEPTH = 2*param_feat2_x

/*** 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 (D34)

2.700000e+00

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

/*



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.



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 t he 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



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



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



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


http://silverstone.fortunecity.com/daytona/344/proehelp/fundamentals/rela...

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

RELATION

PARAMETER

NEW VALUE

--------

---------

--- -----

param_sect_1 = sd0

param_sect_1

5.500000e+00

sd1 = 2*sd0

sd1 (D32)

1.100000e+01

/*** Relations for section:



/*


sd3 (D34)

2.700000e+00

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



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'')

mp_volume (``path'' )

mp_surf_area (``path'' )

for mass

for volume

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



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



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



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



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



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



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 hos ting • domain names web de sign • online games

Relations

Recommend Documents