In our last Post here at the Dojo I talked about Precise and Imprecise assemblies and revision rules and all that. Frankly though, the post suffered by not using any graphics to illustrate the principles. So today I want to make up for that with a post that’s short(er) on prose and long on illustrative examples. I hope you find this helpful.

Setup

We start the examples with four component items with two revisions, 01 and 02, of each. Each revision may be Released, meaning it has a status, or working, meaning it has no status.

Next, we have two assemblies which both use these four components. The first, IMP-100, has an imprecise assembly structure, while the second, PRE-200, has a precise assembly structure.

The imprecise assembly stores references to items not item revisions.

The precise assembly stores references to specific item revisions, not items. In this case it refers to revision 01 of each of its components.

Comparing Rev Rules

So let’s now compare how various revision rules configure these structures.

Latest Working Revision Rule

The first rule we’ll look at is,

1. Latest Working

The Latest Working revision rule will configure the assembly with only working revisions. Since Both revisions of CMP-001 are released it cannot choose any revision to load; neither is a working revision.

You can also see that regardless of whether the assembly is precise or imprecise they are configured with the same revisions.

Latest Released Revision Rule

The next revision rule is,

1. Latest Released

Latest Released is the mirror image of Latest Working. It will only configure released revisions, so in this case it’s CMP-004 that cannot be configured because it has no released revision.

And again, it makes no difference if the structure is precise or imprecise.

Latest Working/Latest Released Revision Rule

Now we start looking at multi-line revision rules. When a revision rule has multiple lines it will evaluate each line in order in an attempt to configure a revision.

The first multi-line revision rule we look at is

1. Latest Working
2. Latest Released

If you compare these results to the simple Latest Working rule you will see that CMP-002, CMP-003, and CMP-004 have the same revisions configured, but CMP-001, which couldn’t be configured before, is now configured with rev 02, its most recent released revision. When the rule couldn’t find a working revision to configure it evaluated its second line and found that it could configure a released revision instead.

And yes, it didn’t matter if the structure was precise or imprecise.

Latest Released/Latest Working Revision Rule

To continue to work through the permutations, we try the reverse revision rule:

1. Latest Released
2. Latest Working

These results look nearly identical to the simple Latest Released results, but where Latest Released couldn’t configure a released revision for CMP-004, this rule is able to configure a working revision instead.

And yes, the results are the same for both precise and imprecise structures.

Precise Revision Rule

By now you may be thinking that there’s no difference between how revision rules configure precise and imprecise assemblies. So let’s take a look at some cases where there is a difference. We’ll start with a revision rule that configures the precise structure:

1. Precise

Now we see some stark differences. PRE-200 is configured with revision 01 of each of its components — the revisions which make up its precise structure. Whether the revisions were released or working had no bearing on their being configured.

IMP-100 is a completely different story. By definition of it being an imprecise structure it doesn’t have any precise revisions, so it isn’t able to configure any.

Now you can see why many installations of Teamcenter only use precise structures. You can make a precise structure configure imprecisely, but you can’t make a imprecise structure configure precisely.

Mixing Precise and Imprecise Sub-assemblies

Let’s finish this with some more complex examples. For these we’ll use a new assembly, PRE-300, which contains the other two assemblies as sub-assemblies:

Mixed Sub-assemblies with a Precise Revision Rule

First we look at how this assembly is configured by the same Precise revision rule we looked at above.

1. Precise

What you see is that the two sub-assemblies are configured identically to how they were configured by the Precise revision rule on their own.

Mixed Sub-assemblies with a Precise/Latest Working Revision Rule

To make it more interesting let’s look at this revision rule:

1. Precise
2. Latest Working

What happened here is that PRE-200 is configured with its precise structure, the same as before, but since IMP-100 has no precise structure and can’t be configured by the first line it’s instead configured by the second line, Latest Working. The sub-assembly IMP-200 is configured the same as it was configured by the Latest Working revision rule we looked at above — and again, since CMP-001 has no working revision it cannot be configured.

Mixed Sub-assemblies with a Precise/Latest Working Revision Rule

To round out the examples we’ll look at

1. Precise
2. Latest Working

As you can see, PRE-200 looks the same as before, only using its precise structure, while IMP-200 now looks like the Latest Working example above.

Closing

Hopefully these examples are helpful in understanding precise and imprecise assembly structures. I encourage you to make your own assembly structures and revision rules and work through some examples on your own.
Please leave your questions and comments and, if need be, corrections, below.

Related Posts

• Understanding Precise and Imprecise Assemblies