Leverage model states for assemblies, iParts, iAssemblies,

00:02

Leverage model states for assemblies, iParts, and iAssemblies.

00:06

After completing this video, you'll be able to

00:08

change a place model state inside an assembly, create a derived part and identify options,

00:14

utilize Edit Factory Scope versus Edit Member Scope, and change placed iPart or iAssembly.

00:21

Inside Inventor, we want to begin with two supplied data sets,

00:25

Blower.iam, which can be found in the assembly subfolder under the Blower subfolder,

00:29

and iPart Angle.ipt, which can be found in the top level of our project.

00:34

We're going to be exploring how we can use iParts as well as model states inside of various assemblies.

00:39

First, in our blower, if we expand the Model States folder, we should see Model State 1, which has CTube suppressed.

00:47

If you don't see this, make sure that you do add a new model state and suppress at least one component.

00:52

From here, let's go ahead and create a new blank assembly.

00:56

Once we have a new assembly, we'll select Place and we want to place the blower inside of here.

01:02

We just need to search for blower.IAM, make sure it's selected, and select open.

01:08

We'll right-click and place grounded at origin, and then hit ESC so we stop placing additional components.

01:14

Now that we've placed this in here, we can expand it and expand the model states,

01:18

and note that we still have Primary and Model State 1.

01:21

Model states can be toggled back and forth for components and parts in an assembly.

01:26

Also note that at the very top we've got our own model states in this new assembly.

01:31

By right-clicking on the Model States folder, we can create a new model state.

01:35

And in Model State 1, we want to activate our Model State 1 inside of our blower.

01:40

Then when we go back to our Primary, it automatically toggles back and forth between those model states.

01:46

So, in a part or an assembly, we can use model states to control

01:50

the visibility, the suppression state, even the material and appearance of certain components.

01:55

If we add a top-level assembly, we can use those model states to not only control those types of features,

02:01

but also the model states of subassemblies and components as well.

02:05

We also have the option to right-click and create a new substitute.

02:10

In this case, if we select Derive Assembly, we need to make sure that we save the assembly first

02:15

and then we can create a derived version of it.

02:17

A quick note, the pencil icon is telling us that we're using Edit Member Scope and not Edit Factory Scope.

02:23

Remember, the difference between Edit Member Scope and not Edit Factory Scope

02:27

determines whether or not changes to a model state will affect all model states or only the current one being edited.

02:34

Let's go ahead and save this assembly.

02:36

We're going to call this Blower Model State (MS) Assembly.

02:44

We'll select Save and then we'll select Primary, right-click and create a new substitute.

02:51

We'll select Derive Assembly and OK.

02:55

When we create a derived assembly, we have several options that we should explore.

02:60

If we expand this, you can see that each component will have its own option.

03:04

When we take a look at the status, we can either include the selected components,

03:08

we can exclude them, and in some cases, we have other options like including a bounding box.

03:14

In this case, everything but the CTube we want to set as a bounding box.

03:18

So I'm going to select multiples, use the bounding box option, and then we'll go from the EX component all the way to the bottom,

03:25

noting that not all of them will include the bounding box option.

03:29

This is not available for every type of component.

03:32

And in this case, you can see the frame skeleton was selected and it needs to be deselected.

03:36

If we do this, we'll create a basic bounding box for all internal components, leaving only the CTube or that exit on the blower.

03:45

We can say OK, and now we've created a new substitute that's a simplified version of our model state.

03:51

In our assembly we can always go back to our primary model state,

03:55

or we can expand our substitutes and go to that new derived model state.

03:60

Inside of our assembly, let's go back to Assemble and let's place another component.

04:04

In this case, we want to place the iPartAngle.ipt.

04:09

This is going to be at the top level of our project and we'll select iPartAngle.

04:14

When we place an iPart inside of an assembly, we have a table that allows us to select which variation of this we want to place.

04:21

If I left-click and place this and then dismiss my dialog,

04:25

we've now placed a table-driven part. Inside of our new assembly.

04:29

If we right-click on the table, we can change the component and we can pick a different variation of that, select OK and have it change.

04:38

When we select a different model state, notice that this part, because we were using Edit member scope, is currently suppressed.

04:46

This is part of the reason why we should use model states inside of our assemblies.

04:50

And remember that when we're using Edit Factory Scope, changes will apply to everything we do.

04:56

Let's repeat this process by selecting and deleting the iPart Angle,

05:00

going back to primary, but in this case, we're going to toggle on Edit Factory Scope.

05:06

Next, we're going to place the component once again adding iPart Angle.

05:10

We'll go to our table, select the 2nd row, place, and then dismiss the dialog.

05:16

Now, if we go to Model State 1, you should see that component is there.

05:20

If we toggle back off the Factory Scope and use Edit Member Scope and go to our table, we can change the component.

05:28

In this case, we'll go to the third variation and say OK.

05:33

Now when we toggle back and forth between our primary and Model State 1,

05:37

not only are we configuring the model state of our blower assembly,

05:40

we're also configuring the specific iPart that we're using in our iPart that's been added to our assembly.

05:47

So model states are a great way to configure many different aspects of your assemblies

05:51

and make sure that you do understand the implications of Factory Scope versus Member Scope

05:56

and how to work with model states as well as table-driven parts like the iPart we added here.