Professional Documents
Culture Documents
ProfilesMagazine.com Home
Past Issues
Contact Us
The following tips build upon the information presented in my previous Pro/files
article, “Reverse Engineering.” For those of you who didn't read that story, I’ve
included a summary of Pro/ENGINEER's TDD toolset in addition to guidelines for
planning and implementing a top-down approach.
Parametric Autonomy
Pro/ENGINEER is a parametric modeler at its core. The price you pay for this
power, however, is that it creates parent/child relationships. With the toolset Pro/
ENIGINEER provides, we can easily weave ourselves into a mess of circular
references that overload our hardware as well as our own patience.
Here’s a quick summary of the TDD tools that Pro/ENGINEER currently offers.
External Reference Control. Available through the Utilities menu, this tool is
really handy for protecting your models from inheriting references from
unauthorized locations. Referencing from skeletons is best because the skeleton
models are the foundation of your design and are controlled against change. You
can also choose settings that allow only published geometry to be selected, and
color or hide forbidden references.
Most favorable settings for External Reference Control.
If you’re using “mirror” to create parts or assemblies, you must change your
scope setting from skeleton_model to all.
Global Reference Viewer. The global reference viewer (GRV), the granddaddy
of the top-down design tools, tells you where your external references reside. If
you've made copy geometry features, the GRV will let you see them.
Info: Parent/Child. Similar to the global reference viewer, this tool shows you
any parent/child relationships. You can access Info:Parent/Child using either the
right-click option on a feature or the Info top-menu.
Skeleton Models. Skeleton models provide the foundation for our parametric
autonomy paradigm. The function of the skeleton model is to:
Layouts. Layouts generate the key input data for skeletons, models, assemblies,
and relations. Using a static 2D sketch along with parameter tables, we can
communicate design intent and produce a history of a design’s evolution. A
layout immediately reveals what the important datums are and what the design’s
key dimensional constraints are. You typically use layouts from large assemblies
down to a medium-size subassembly. Occasionally, interface layouts are used to
control bolt circle information or connection information that may not be suitable
to document on a subassembly layout. (More about layouts later.)
Using published geometry forces you to manage and control your copy geometry
references. Think about a team environment. If a team leader is managing the
assembly, it is his or her responsibility to control the references and the general
constraints of the assembly. By using published geometry, a team leader can
therefore decide which references are valid and publish them for use, thus
minimizing the problem of bad references. (Recall the External Reference Control
option of “published geometry only.”)
Relations. Relations are the way to link the data input values from your layouts
to your skeleton, part and assembly features. Using logic operations and
condition statements, you can create geometry that can adapt under certain
conditions.
During the planning and conceptualization phase, we rough in our assembly and
create our skeletons and layouts. Unfortunately, this is the stage that
overwhelms most users new to TDD and the one skeptics complain takes too
long. Once you have a procedure everyone follows and then practices, however,
I don’t find that using TDD upfront adds much time to the finished design. In
fact, planning is the most important step because we want to form—and
document—our design intent. While all CAD systems lack good tools for this
documentation process, Pro/ENGINEER makes up for this deficiency somewhat
by integrating layouts and skeletons.
Home Coordinate System. Your “home” coordinate system is the one that’s
common to all of the assemblies and subassemblies in your drawing tree. For
example, if you were designing a car, you’d have assemblies for body, engine,
and interior. These are major assemblies that relate to one another, so they
would share a common coordinate system.
Layouts. Layouts let you sketch out your 2D representation. I prefer to use
imported AutoCAD data or IGES data, but in a pinch you can do some
rudimentary sketching in Pro/ENGINEER. In general, you should have one layout
for every major assembly and possibly another one for each level below.
Remember, the idea is to capture layout data that is specific to the assembly
you’re working on.
● Place all interface datums in the layout using proper naming conventions.
Be aware that the yellow side of the datum gets created by the direction in
which you pick your points when placing draft datums, so practice and get
used to it. The datum direction is only important if you plan to use layouts
for automatic placement. Identify your home coordinate system if
applicable.
● Keep a table showing parameters pertaining only to the design and not to
the layout itself (e.g., naming/part numbers for layout tracking). To
facilitate this, I use a naming convention to filter out layout-related
parameters, typically prefixed by “LY_”. Be sure to include a comment
column to describe the parameters’ usage. You may want to create a
standard table that you can retrieve, thus creating a standard look.
● Avoid declaring layouts to each other. Otherwise, you can end up with a
mess of parameters declared to parts that are not required.
● Use meaningful names for your key datums. The terms you use for your
base datums will be the same as those for your parts, skeletons, and
sometimes assemblies.
And remember: the layout is an excellent place to store design notes and
document your design intent.
Start Parts and Layering. Before creating any geometry, it’s best to plan out
what information will be required from the parts—typically in the form of
parameters. If you already have start parts or templates, you’re probably all set
but you might read through this section to be sure you’ve covered your bases.
Start parts are great simply because you can define a layering rule, default
parameters, default relations, and so forth. Creating your defaults in your start
parts also eliminates the need to do this with config.pro options, which never
really worked well. When you create a start part, it’s a good idea to use a base
start part with features common to all parts. I keep a start part for skeletons,
piping parts, sheetmetal parts, and machined parts.
Default layer items are best served by associating entity items to be placed
automatically on layers. You can set your layer properties either during creation
by using the “new layer” button or by right-clicking the layer and selecting Layer
Properties. When you name your layers, include a digit in the prefix so you can
organize the layers in sequence.
The “isolate” function in the layer box is ideal for putting your assembly datums
on a layer. Isolating a layer in effect tells Pro/ENGINEER to ignore the status of
any items in the layer. This means that even if the items are on other blanked
layers, Pro/ENGINEER will still show them.
Setting the Layer Property
Below I have listed the recommended options for your config.pro and/or config.
sup files. Use the config.sup to prevent user independent config.pro settings.
(You will need to consult the PTC documentation because some config.pro
options do not work properly when placed in the config.sup.)
OPTION SETTING
allow_ref_scope_change yes
default_ext_ref_scope skeleton_model
default_object_scope_setting skeleton_model
enable_component_interfaces yes
force_new_file_options_dialog yes
maintain_limit_tol_nominal yes
modelcheck_enabled yes
multiple_skeletons_allowed yes
new_parameter_ui yes
new_relation_ui yes
open_simplified_rep_by_default yes
sketcher_intent_manager yes
scope_invalid_refs prohibit
Default Datums. The default 3 planes and coordinate system usually requires
an axis. Create any default datums you feel are necessary for most parts.
Parameters and Relations. Default parameters are used for consistency and
compatibility with any formats you’ve defined. You can add parameters used for
describing the part, bill of material information, and weight calculations. Pro/
ENGINEER 2001 introduced a new parameter user interface as a hidden option,
which you can use by setting the configuration option new_parameter_ui to yes.
Adding relations to your start parts is also quite handy. For example, you can
create relations to store the mass of a part as a value or automatically add a
prefix to your part number. In Pro/ENGINEER 2001, you can use the new relation
user interface by setting the configuration option new_relation_ui to yes.
Settings to store last known value for weight and center of gravity.
Skeletons. Skeletons form the geometry prescribed by the layout. Since they
are very lightweight and very fast to regenerate, I recommend having a skeleton
for each assembly. If I’m working on an assembly that only has a few
components, I’ll sometimes use assembly datums rather than a skeleton. But if
your assembly has three or more components, skeletons are a better choice.
● Name your interface datums. I find that using a prefix like “SK_” followed
by the datum name used in the layout allows quick identification during
query select.
● Use a layer scheme, typically defined by your start parts. Don’t be afraid
to add more layers to group key datums. (By using the isolate layer
option, you will see only the datums required for assembly.)
Copy Geometry. Ideally, you should limit the use of copy geometry as much as
possible. The nasty thing about copy geometry is the parent/child relationships
that it can create. Imagine working in a large assembly consisting of a few
hundred parts. If you make a copy geometry to a part in a subassembly, Pro/
ENGINEER stores the reference required to regenerate the copy geometry in the
part. To redefine the copy geometry, Pro/ENGINEER will now have to retrieve
that assembly with those few hundred parts into session. The retrieval scenario
applies in the Pro/INTRALINK environment as well, compounding the problem
because Pro/INTRALINK will manage any changes to the large assembly across
any versions saved.
I suggest using copy geometry for visual references only. Since we drive our key
dimensional attributes from a layout, there is minimal need for copy geometry.
In fact, minimizing copy geometry helps to fulfill parametric autonomy.
Another place that users get overwhelmed in top-down design is at the “where-
to-begin” dilemma. I find it best to start with the upper-level assembly and
create its skeleton model and develop some geometry using datums. At the
same time, I also create a temporary drawing of the skeleton to export as a .dxf.
I then import the .dxf as groundwork to insert dimensions (parameters) in layout
once the skeleton is well roughed in, or to sketch a 2D geometry reference in
another CAD program. Note: Wildfire 2.0 has great AutoCAD support (from
release 12 to 2000), offerng a host of options for importing your AutoCAD
drawings cleanly.
● robust geometric references for copy geometry, which you can then use to
create part features (although I strongly caution against using copy
geometry for part features), and
● a great way to control your datum and surface features in your skeletons.
When using a skeleton to “sketch” your idea, you will also be trying to get a
reasonable start on usable dimension values. To define your design, you’ll find
that you do a little bit of skeleton work and then layout work. You don’t
necessarily do one before the other, and quite often the process is a parallel
effort.
2. Associate Values from the Skeleton to the Layout
Once you have a working skeleton, it’s a good time to populate a layout that
contains parameters required to drive the key areas of the skeleton. Declare the
layout to your skeleton and start associating your values to your skeleton and
parts.
Another complaint I hear about TDD is that it’s “too restrictive” and “I can’t edit
dimensions on the fly, since I have to set values in my layout.” To disprove these
claims, let’s assume you’ve created datums and curves, and perhaps even some
surfaces in your skeleton. You’ve also made key parameters in your layout with
no particular value since you don’t really know what’s required.
At this time, declare your layout (Declare option in the part menu). To link the
values in your layout to your skeleton, you have to create relations. Don’t do this
quite yet since you have different values in two places. You should therefore set
the parameter values from your skeleton into your layout parameters. Now you
may create your relations and regenerate your part. Of course, nothing will
happen since the values are identical.
Making edits to many values using the layout can be tedious. At the same time,
layout does not allow you to use the dynamic drag functionality to “eyeball”
geometry changes. So what you do is simply “comment out” the relations in the
relation editor to let Pro/ENGINEER temporarily assume these relations are not
required. To comment out a relation, put a “/*” (slash-asterisk combination
without quotes) on the leftmost side of the relation. Now start modifying your
feature. When you find the dimensions you like, simply edit your layout with the
values, uncomment the relations, and regenerate.
Creating copy geometry is a step in the process whether you use it to drive
geometry (not preferred) or as general visual feedback geometry (preferred). At
this point, we have a working skeleton and layout. You can now start creating
some published geometry to contain the working references other designers (or
yourself) are allowed to use for referencing your skeleton datums.
We’re in the homestretch now. By this time, you’ve put a lot of effort into
creating skeletons and assembly structure by way of subassemblies and
subassembly skeletons. You can now integrate parts you’re designing—whether
they already exist or are being modeled for the first time—into your TDD
assembly structure.
For existing parts, take the opportunity to update your models to utilize the
layouts you’ve created. Since TDD can be implemented into existing designs (see
my previous article, “Reverse Engineering”), you can slowly update your legacy
models to take advantage of a TDD practice.
For parts you are now creating, you should assemble the part with its default
datums so that they are the first features of the model and less likely to change.
If you cannot use the default datums, be sure to make your assembly datums in
the part as early as possible. As you design your part, keep in mind which
features are going to be driven by the layout.
This is when you get the payoff from parametric autonomy. While copy geometry
may be faster, you pay in the end for managing the references and for risking
bad references. You will find you model the same “feature” more than once, but
once you link those features with the layout, any updates require only that the
layout be in session.
By this time, you’ve created an assembly, skeletons for the assemblies, and
layouts to drive the skeletons and assembly components. Now you are most
likely ready to start tweaking for a final design. You should start to experiment
by modifying values from your skeleton models and layouts to test your model’s
robustness.
Summary of Benefits
Since advocating against copy geometry for production design is likely to evoke a
lot of complaints, I want to explain my reasoning and the benefits of my
parametric autonomy approach.
The solution? Minimize the dependencies. Rather than create a copy geometry in
an assembly, create a layout to drive the geometry. You only have to deal with
two dependencies—the layout and the part it is declared to. If you declare the
layout to more parts, those declarations still have no effect on the first part
unless you change the layout. In contrast, if you mistakenly create a copy
geometry while in an assembly with 1,000 parts, you need that 1,000 part
assembly in session to update any copy geometry.
2. Rapid changes with skeletons. If done well, you can create a simplified
representation rule at the highest level of your assembly and include only
skeletons of everything below it. With layouts and straight geometry
modification, you can make large shifts in your model with minimal regeneration
time. After saving your assembly and any modified skeleton models, you can
then start regenerating the subassemblies to implement the change. In this way,
you reduce the amount of hardware resources at any given time to ensure safe
regeneration.
I would like to emphasize that PTC places great value on all of its interactions
with both the PTC/USER board and membership. PTC carefully evaluates our
feedback in its product planning process and in initiatives to improve its
operating procedures in areas such as technical support and quality assurance.
The breakout story this year was the very rewarding attendance and feedback
from our Windchill committees. While interest and participation have been
building for some time, this year’s sessions were by far the most productive and
well-attended. Special thanks to Windchill chairpersons Jeff Zemsky and
Dominic Hand for their time and leadership, and to PTC for its management and
development presence.
Leadership Changes
We welcome Ron Grabau back as he takes up the lead of Core Modeling. Ron
has been active in the PTC/USER community for many years and has played
several key roles, including a previous stint as Core Modeling TC chair.
Mark Crum has accepted full chairmanship of the Data Management Technical
Committee. He has been doing an excellent job as acting chair since Ben
Franklin’s departure.
Here are brief summaries of recent and planned activities prepared by several of
the Technical Committee chairs.
Core Modeling. The Core Modeling TC had one of its best-attended meetings in
June. While most of the subjects fall under nondisclosure agreements, the
committee generally addressed updates to Wildfire 2.0 as well as future Pro/
ENGINEER enhancements. The topics of discussion ranged from simple user
enhancements to complex issues spanning multiple Technical Committees.
The Core Modeling TC is now looking at ways to organize better itself to address
a wider range of topics. While still a work in progress, the reorganization should
be finalized before the next conference. Although the Core Modeling committee is
currently full, the group welcomes input from the entire user community. Contact
any committee member to submit ideas and papers for consideration.
The next release of Wildfire is at the end of the specification phase. PTC’s Scott
Conover went over the planned enhancements. Customization committee
members volunteered to review the specifications and offer feedback from the
user point of view.
Data Exchange and Archiving. Members of the Data Exchange and Archiving
Technical Committee reviewed improvements in Wildfire 2.0, enhancements to
Wildfire 3.0, and white papers for future improvements. The TC will continue to
meet via webcast every six weeks or so to comment on Wildfire 3.0 functionality
before enhancements go into the software.
Drafting. Drafting conducted webcasts throughout the year. The June meeting
was well-attended by member companies and PTC product management. Areas
of discussion included implementation of Y14.41, user enhancements, symbols,
future releases of PTC software, and white papers.
PDS. In June, the PDS Technical Committee announced the release of its Top
Down Design and Change Management Process Guides. The TC is currently
working on the Release to Manufacturing Guide and will begin on the
Collaboration Guide and Project Management Guide in the next couple of months.
PTC has made a lot of great enhancements and improvements to the tool.
Wildfire 4.0 should have a whole new look and feel for cabling. It's exciting to
see that PTC is paying more attention to electrical/mechanical design than it did
10 years ago and that the Routed Systems TC will have a lot of influence in what
this tool becomes.
● Wildfire 3.0. PTC presented its plans for what the next release will involve,
sparking several new discussions that will continue over the next few
months and in our January meeting. Several new project specifications
were divided among the TC members to review and provide feedback to
PTC.
After one of the most successful and well-attended Product Update Briefings at
the PTC/USER conference, the Sheetmetal TC is welcoming four new members.
With these additions, the TC now boasts 17 members in North America that bring
a range of experience and industry expertise to the table. The TC is still
accepting members into our workgroup and has plenty of openings in the review
group.
Going forward, the TC will focus on development of Wildfire 3.0 (and beyond)
development to help enhance functionality and ease of use. Members will also
continue to refine the TC’s list of priorities, which will then be combined with
PTC’s. This will hopefully allow the Sheetmetal TC and PTC to develop a module
that suits the user community as well as keeps PTC competitive in the
marketplace.
The Sheetmetal TC would like to thank PTC, and especially Gilles Combette, for
making the Wildfire 2.0 Sheetmetal module one of the most advanced and easy-
to-use releases in some time. Thanks also to PTC management for their
commitment to improving the Sheetmetal module with each release that follows
Wildfire 2.0.
Usability and Training. The Usability and Training Technical Committee discussed
areas of usability, training and ModelCHECK. CADTRAIN is updating its COACH
content to support Wildfire 2.0 and a free Wildfire 2.0 Primer is already available.
PTC provided an update on PTC University, which brings together all areas
associated with learning—from searching for training opportunities to tracking
enrollments to accessing role-based communities. Discussions continued about
ModelCHECK’s expanded functionality and user interface enhancements in
Wildfire 2.0. Software Factory also presented information on its geometry-based
checking tools, PE-CHECK and PE-WALLCHECK.
The committee was also briefed on the new 3D annotation capabilities (available
in Wildfire 2.0 Object Adapter), upcoming JT import capability, and the Graphics
Server roadmap. PTC gave an update on the roadmap for dvMockup/Reality and
DSU 5, which now allows the application to run in the latest Unix O/S. Windows
XP support will be addressed in DSU 6. Over the coming year, the committee will
focus on enhanced collaboration capabilities, drawingless manufacturing, digital
rights, and enhanced scalability.
These topics, along with other related Business Process Guides, will receive
additional attention over the coming year. A series of workgroups is covering
reporting and configuration management topics for the next two product releases.
The committee also held further discussion on the need for better collaboration
with other TCs on topics where there is overlap, such as Visualization, Windchill
Infrastructure, PDS, and Data Management. Several webcasts are planned over
the next few months to continue work on the above topics.
Get Involved!
Automation has always been a buzzword for Pro/ENGINEER customers and with
good reason. Automated tasks are fast, efficient and always completed in the
same manner every time. Although its worth cannot be directly measured,
standardization contributes to improved quality as well as faster design and
design changes. For companies, the bottom line is always time, quality and cost
and automation at any level improves the bottom line.
PTC also developed UI Scripting to behave like mapkeys. Users can play back
recorded scripts just like mapkeys. These UI Scripts can even be added as
dropdown menus to the Pro/INTRALINK user interface. The dual nature of UI
Scripting makes it quite a bit more useful than Pro/ENGINEER trail files or
mapkeys. All this functionality is supported by PTC Technical Support.
If you’re worried because you don’t know Java, don’t be. For this foray into UI
Scripting, the only prerequisite is a good working knowledge of Pro/INTRALINK.
Let’s walk through the process of recording and playing back a UI Script. We will
use a script to open the COMMONSPACE and select the Root Folder. Finally, we
will select every object in this folder. Your database won’t look like mine and
production databases should never contain any objects in the Root Folder. Just
choose a sub-folder that contains Pro/ENGINEER files.
1. After logging into Pro/INTRALINK, open the Scripting UI using [ctrl] + [s].
2. Switch to the Recording tab and enter a name for the Java script file to be
recorded. Make sure that “Use Key Recording?” box is checked.
3. Click “Start” and record your picks within the Pro/INTRALINK UI.
5. Now pick one object in the displayed list and use [ctrl] + [a] to select all
displayed objects.
- compiles the script file and places the new .class file in <.proidirectory>\.
data\user.data\lib (i.e.. it reads the .java file and makes a .class file).
- Switches to the Playback tab. Make sure “Use Watch Window?” is checked so
you can watch each line execute for debugging purposes.
7. Click “Playback” and the Scripting UI will switch to the Watch tab. The
commands are described in the table below.
Watch Window Buttons
Button Description
Button Description
executed successfully
failed execution
currently executing
8. Step through the program. After selecting Step twice, my Watch tab looks like
this:
We only made three selections, so why are there four lines? Sometimes Pro/
INTRALINK executes more than one command when we click a button. By setting
the folder, the software automatically filtered the display to show only the latest
versions. PIV stands for product instance version. Every line displayed in the
COMMONSPACE table is a PIV.
9. Continue to step through the program. If the script fails for any reason switch
to the Errors tab. If no errors are reported, switch to the Messages tab for any
additional information.
Pro/INTRALINK scripts can be run from the Scripting UI using the Playback
button as we did above. But this method requires users to understand the
scripting interface. Fortunately, PTC took into account the mapkey scenario for
UI Scripting. UI Script creators can add a custom dropdown menu to the
WORKSPACE or COMMMONSPACE folders by simply copying the compiled “.class”
file to the “<.proi Load Point>\.data\user.data\custom\WS” or “<.proi Load
Point>\.data\user.data\custom\CS” directories as shown below.
A Pro/INTRALINK client command line argument lets you record everything from
user login to session close. Record a script from the command line by calling the
Pro/INTRALINK client startup command, followed by the option “-r” and the
name of the file to record.
proiclient.bat -- -r test.java
The script can in turn be executed from the command line using the Pro/
INTRALINK client command line switch “-p”. The class to run must be in the “lib”
folder. Command line scripts can even be run in nongraphical mode just like a
Pro/ENGINEER trail file. The Pro/INTRALINK startup command shown below puts
all these elements together. It calls Pro/INTRALINK in nongraphical mode and
runs a UI Script.
Although the above example isn’t very useful, there are numerous applications
for UI Scripting. Incorporating the above functionality with a few manual edits
can build very powerful automations. Have you thought of any applications for UI
Scripting now?
UI Scripts can execute custom check-outs/ins, modify object attributes, and even
produce custom reporting which helps focus on better-quality products.
Administrative scripts can automate the purge process or export a Pro/
INTRALINK BOM to an ERP/MRP system, reducing the time spent managing the
data. Configuration scripts can be used to populate folders complete with
permissions or to create users and groups in seconds.
Work through the entire process, practice your picks, and when you are ready,
record your script. Always keep in mind the end goal. A script that saves time for
every user every day may be just as valuable as the automation of a product line.
Have you ever wanted to open more than one model at a time from
a workspace? In Pro/ENGINEER 2001 and Pro/INTRALINK 3.2, all
you have to do is:
1. Select the files you want to open from the workspace using the left mouse
button and the ”ctrl” key.
2. Click the right mouse button and select Open. Each model will open in its
own window.
This works with family table instances or standalone models—with or without Pro/
ENGINEER running.
A word of caution. Opening too many models at a time may cause video card
problems or even lock up your system, depending on the system you have. I
have successfully opened 11 at once, although things got a bit weird. Opening 10
or fewer at one time has not given me a problem.
Decals are a great way to add a company logo or label and just a
bit more realism to a photorendered model. But do you know the
shortcuts for making decals easier to use and providing better
display quality?
The first two tips below outline the basics of creating and applying decals. The
second two are timesavers that will improve the flexibility and quality of the
rendered output. Note: Although you don’t need Pro/PHOTORENDER to create
decals, the final product will be better if you create your images with it.
Creating a Decal
3. Add a new “color” by clicking on the + symbol in the right-hand side of the
Appearance Editor window. Name the new color if desired.
5. Click on the empty gray square located under the Decal heading.
8. Click on the desired decal file in the Appearance Placement window and
click Close. You now have a decal ready for application.
Applying and Adjusting a Decal
2. Select the “color” that represents the decal from the Appearance Editor
window.
3. Select where the decal will be placed from the Assignment heading of the
Appearance Editor window (i.e., Part, surface, quilt), and select the
corresponding reference.
4. For best results, orient the model so that your view is normal to the surface
where the decal will appear.
6. To edit the size, quantity and location of the decal, click on the picture of
the decal preview located under the Decal heading of the Map tab of the
Appearance Editor window.
7. Click on Mapping to adjust to the shape of the geometry where the decal
is to be applied.
10. Drag the X, Y and Rotate dials of Position to adjust the location of the decal.
11. Click Close on both the Appearance Placement and Appearance Editor
windows when you are done making adjustments.
The first timesaving tip involves creating an “outline” of where your decal will
appear. This step has several benefits—it takes the numerical guesswork out of
scaling the decal, makes it easier to adjust its proper location, and automatically
“crops” the decal when you scale it, so that you cannot exceed the size outline of
the created surface.
2. Sketch an outline to represent the size and shape of the finished decal.
6. Apply and adjust the decal as instructed above, using the created surface
bounded by the sketched curve as the assignment for the decal.
7. To adjust the location of the decal on the model, you can edit the surface
feature. This allows access to the dimensions used to create it, and thus provides
an easy (not to mention parametric) adjustment to the decal location. Because of
the novel way Wildfire operates, if you adjust the curve location, the
corresponding surface will not adjust.
1. After completing the preceding tip, select the surface that represents the
decal outline.
5. Apply and adjust the decal as instructed above, using the offset surface as
the assignment for the decal.
This tip uses family tables, relations and user-defined parameters to create a
straight tube instance from a formed tube. Because a tube stretches as it is bent,
the relation equations use a stretch factor for determining the actual length
needed. Using the steps outlined in this tip, holes in the tube also can be
correctly positioned on the straight tube based upon their intended locations on
the bent tube.
The generic model for this application is created from straight datum curves set
at specific angles to each other. For each bend that is not coplanar with the
previous bend, you must create a pair of datum planes, one normal to the
existing straight curve and the other for sketching the new curve. A pipe feature
with a constant radius is created through the endpoints of the datum curves to
form the bent tube. Holes can be placed anywhere along the tube as long as
their references stay relevant as the tube becomes straight. Holes between
bends are dimensioned from one of the ends of the datum curve defining that
portion of the tube.
1. The bend radius remains the same throughout the formed tube. It is
possible to use different radii but my application uses a common radius for each
tube. Different bend radii would require multiple RAD parameters and likely
different bend stretch factors (BSF parameters) because tube stretch can vary
with the size of the bend radius.
The stretch factor is determined empirically. Straight tubes are measured prior
to bending and measured again with CMM equipment after forming. The
difference between the centerline length of the bent tube and the length of the
straight pre-bent tube is the amount the tube stretched. Divide that amount by
the sum of the bend angles to get the bend stretch factor in millimeters per
degree.
It can be useful to blank the pipe’s centerline by putting the pipe feature on a
layer and blanking that layer. The solid will continue to display but the centerline
will disappear.
In the following diagram, you will see how we arrive at the length adjustment for
the stretch formula.
Relations File
I have included the relations file that I use to create my bent and straight tube
instances. You can copy this file and then edit the appropriate values for your
application.
ANG1=(180-BEND1)/2
ANG2=(180-BEND2)/2
ANG3=(180-BEND3)/2
ANG4=(180-BEND4)/2
ANG5=(180-BEND5)/2
BD1=ANG1*RAD*PI/180-RAD*TAN(ANG1)-BSF*ANG1
BD2=ANG2*RAD*PI/180-RAD*TAN(ANG2)-BSF*ANG2
BD3=ANG3*RAD*PI/180-RAD*TAN(ANG3)-BSF*ANG3
BD4=ANG4*RAD*PI/180-RAD*TAN(ANG4)-BSF*ANG4
BD5=ANG5*RAD*PI/180-RAD*TAN(ANG5)-BSF*ANG5
/*************************************************/
/*************************************************/
IF BENT == YES
/* Segment lengths:
D_SEG1=SEG1
D_SEG2=SEG2
D_SEG3=SEG3
D_SEG4=SEG4
D_SEG5=SEG5
D_SEG6=SEG6
D_CUT1=CUT1
D_CUT2=CUT2
D_CUT3=CUT3
D_CUT4=CUT4
/* Bend angles:
D_BEND1=BEND1
D_BEND2=BEND2
D_BEND3=BEND3
D_BEND4=BEND4
D_BEND5=BEND5
ELSE
D_SEG1=SEG1+BD1
D_SEG2=SEG2+BD1+BD2
D_SEG3=SEG3+BD2+BD3
D_SEG4=SEG4+BD3+BD4
D_SEG5=SEG5+BD4+BD5
D_SEG6=SEG6+BD5
/* Cut dimensions to TSC:
D_CUT1=CUT1+BDn
D_CUT2=CUT2+BDn
D_CUT3=CUT3+BDn
D_CUT4=CUT4+BDn
/* Bend angles:
D_BEND1=180
D_BEND2=180
D_BEND3=180
D_BEND4=180
D_BEND5=180
ENDIF
2. Create a bent tube model using datum curves with bend dimensions
referencing inside angles and straight segment lengths between ends and
Theoretical Sharp Corners (TSCs). The Pipe feature will be created through the
endpoints of the curves. Holes between bends should be dimensioned to one of
the TSCs. Use the RAD parameter when defining the Pipe feature’s bend radius.
a. In this example, the first two straight segments are sketched on the FRONT
datum plane (see figure 1).
Figure 1.
b. The second bend is not coplanar with the first bend so the third straight
segment must be sketched on a datum plane (DTM1 in this example) set at an
angle to the previous sketch plane (see figure 2).
Figure 2.
c. For sketching references, select the previous curve and its endpoint (see figure
3). Dimension it with the appropriate length and angle. See figure 4 for the
completed three curve segments.
Figure 3.
Figure 4.
d. Create a Pipe feature with constant radii through the endpoints of the curves
(see figure 5). When prompted for the bend radius, type RAD.
Figure 5.
e. IF there are cuts in the tube, create them now, dimensioning them to segment
endpoints.
Figure 6.
4. Test the tube construction by changing the internal bend angles to 180° to
ensure it forms a straight tube and the cuts don’t fail.
a. Delete unused (or add more) ANGn, BDn, CUTn, SEGn, and BENDn
statements.
b. Check that the bend angle reference in the cut dimension adjustment
statements refers to the correct bend (ex: D_CUT1=CUT1+BD1).
c. Edit the last SEG statement in the ELSE section to include only one BDn
variable.
7. Close the editor and check the text message area for an indication of an
error. Re-edit the file if necessary. Pro/E will add a comment line explaining the
error found in the file.
a. Add the BENT parameter and set its value to NO for the straight instance and
to YES for the bent instance. It should be set to YES in the generic.
b. Add any other parameters unique to either the bent or straight instances.
c. Verify the instances by selecting the Verify icon and clicking on the VERIFY
button.