Create distributed and derived designs

00:02

Create distributed and derived designs.

00:06

After completing this video,

00:07

you'll be able to create and break a design.

00:13

In fusion,

00:14

let's begin with the supplied dataset,

00:16

utility knife.

00:17

F3D.

00:18

This utility knife contains a couple of different components,

00:22

a left and a right-hand side of the razor knife,

00:24

also the left and right hand side of the grips,

00:27

the blade and the blade cradle.

00:29

All these designs have been created inside of a single file infusion.

00:33

And this is a typical workflow,

00:35

but there are other workflows available that we need to understand.

00:38

These are typically called distributed designs.

00:41

Those are designs that have external references.

00:44

And there's also a derived design,

00:46

and there are differences between the two in terms of the direction of flow of data.

00:51

So first,

00:52

when we look at this design,

00:53

we see that we have multiple components.

00:55

There are some joints,

00:56

there are things that are happening

00:58

inside of this design that are all internal.

01:01

As we look at each component,

01:03

the icon represents a single component,

01:06

meaning that there's only a single component and no additional subcomponents.

01:10

And nothing has a chain link icon that would represent that it's external.

01:15

However,

01:15

there are many instances where we may need to take a portion of a design

01:19

and create what's called a distributed design.

01:22

A distributed design is when we take a component or body out of our current design

01:27

and put it into its own file.

01:29

This is often done for manufacturing reasons when creating

01:32

things like fixtures and workflows for CNC machining parts,

01:36

but it can also be done purely for design reasons.

01:39

For example,

01:40

if we needed multiple variations of this blade cradle,

01:43

we can do this by selecting a component,

01:45

going to our create menu and selecting derive.

01:49

We're gonna have to make sure that our current design is saved,

01:51

so let's go ahead and just simply save it.

01:54

And then we have our derived dialogue.

01:56

This can be placed in a new design,

01:58

or if there's an existing design where we want to place it,

02:01

the type will be derived objects,

02:03

or we can derive the entire component.

02:05

The derived objects comes up by default because we pre-selected our component.

02:09

This is going to include the body,

02:11

but we can also include things like sketch parameters.

02:14

We don't need to include anything like that for this design,

02:17

so we'll simply say,

02:17

OK.

02:19

A new design is created that isn't saved and we'll

02:21

note in the browser that we've got a forward arrow.

02:25

This is telling us that we've got a design that has been derived from another design.

02:30

You'll notice that no features have come along in the timeline.

02:33

This is because all of the data goes from

02:35

the original assembly down to our current design.

02:39

This arrow is going to represent the original design flow.

02:42

If we right click,

02:44

notice that we can break the link,

02:46

and we can also figure out things like history,

02:49

which version it was,

02:50

and we can also show its location.

02:52

For our purposes,

02:53

let's go ahead and navigate to a right view.

02:56

We're gonna start a new sketch.

02:59

And we're going to increase the size of this hole.

03:03

We're gonna do this by creating a sketch that's 5 millimeters in diameter.

03:07

Finish the sketch

03:08

and extrude through the part.

03:11

Start to pull it through

03:12

and use the option to go to all.

03:17

Once we've made that change in the blade,

03:18

let's go ahead and do a quick save.

03:22

If we go back to the original design for the utility knife,

03:26

and we isolate the blade cradle by right clicking and selecting isolate.

03:30

You'll notice that

03:31

the whole has not been updated here.

03:34

However,

03:35

if we activate this component.

03:37

Start a new sketch.

03:40

And say we add another hole,

03:42

let's just put one up here.

03:46

Let's do an extrude cut through the design.

03:50

Once again,

03:51

saying through all.

03:54

Right click to isolate.

03:57

Activate our top level

03:59

and save the design.

04:02

Now,

04:02

if we go back to our derived design,

04:04

you'll notice that we've got a yellow triangle telling us that we need to update.

04:09

It's shown here,

04:10

it's shown in the bottom right,

04:11

as well as at the top of the browser.

04:13

We simply need to click on this to update to the current version.

04:17

You'll notice now that the hole has come through to our derive.

04:20

So it's important with derives to understand that the workflow is unidirectional.

04:25

Everything comes from the original assembly and can be

04:28

pushed down into the derived by updating the design.

04:32

In this case,

04:33

let's go ahead and right click on the blade cradle,

04:35

and in this case,

04:36

we want to break the link.

04:38

Breaking the link from the original design

04:41

is not going to bring in all of the features that were used to create it.

04:44

It's only going to cut the link between this design and the original.

04:49

I'm going to go ahead and save this design.

04:52

And then navigate to our utility knife.

04:54

We want to expand the data panel and

04:56

drag the untitled document into the utility knife.

04:59

It's allowing us to drag this in because we broke the link.

05:03

If we still maintained the link between our derived and the original part,

05:06

we would not be able to do this because

05:08

it would create what's called a circular reference.

05:11

To see this in action,

05:11

we can drag the utility knife into its own file.

05:14

You can see here that it's telling us it cannot insert

05:17

the utility knife because it would create a circular reference.

05:20

So,

05:20

we're only able to drag those derives back into

05:23

the original design if we do break those links.

05:26

We can also see this by dragging something else,

05:28

such as our joint sample.

05:31

Notice the icon in the browser is showing a chain link icon.

05:35

We're going to say,

05:36

OK,

05:37

and note that this is now an external reference design.

05:41

This X ref or this external reference is what's called a distributed design.

05:46

This means that the files used to create

05:48

these assemblies are distributed in different locations.

05:52

We can right click on this,

05:53

and we can break this link,

05:55

and that will allow us to bring all of the

05:57

different features used to create it into our current design.

06:00

Again,

06:01

this is different

06:02

from talking about a derived design,

06:05

because all of the data and all the features come from the original assembly.

06:09

However,

06:09

when we're dealing with distributed designs or external links like this,

06:13

all of the data,

06:14

the history,

06:15

the sketches,

06:15

the features

06:16

can be brought in in an unbroken state,

06:19

or we can break the link,

06:21

and then we can have an independent version of that in our assembly.

06:25

Whether or not you decide to use externally referenced components or

06:29

use derive or create all of your designs in one place,

06:33

that really depends on the types of things you're modeling and

06:36

whether or not you're working or collaborating with other users.

06:39

There are many instances where there is a mix of these

06:42

where we have derives and distributed designs in one place.

06:46

Again,

06:46

it just comes down to understanding the basics of how these work in context.

06:52

There are some other things that we

06:53

should understand about externally referenced designs,

06:57

such as the edit in place workflow.

06:59

The Edit in place workflow allows us to make associative edits to our design

07:04

in the context of our current assembly.

07:06

We're not going to go deep into this topic here,

07:09

but it's just important at this stage to note that

07:11

we can make edits to the original sketches and features,

07:14

and even add new geometry or features by using this edit and place functionality.

07:20

At this point,

07:21

let's go ahead and close the utility knife without saving this joint sample

07:25

because we aren't going to need it in that design.

07:28

Also,

07:29

let's go ahead and close the untitled document,

07:31

because we aren't going to need that derived as well.

07:34

But at this point,

07:34

it's important that you at least play

07:36

around with and understand the differences between

07:39

bringing an external reference design into an assembly,

07:42

as well as deriving something out from your current assembly to its own file,

07:47

how those work,

07:48

and the differences between them.

07:50

After you're done and everything's closed,

07:52

go ahead and move on to the next step.