Upload/Share Project Models Using Autodesk BIM Collaborate

00:00

[MUSIC PLAYING]

00:11

BRYSON ANDERSON: Autodesk accelerators

00:12

are designed to help your team stay ahead

00:14

of the curve with the latest workflows.

00:16

These include on demand courses, pre-recorded coaching,

00:19

as well as live coaching.

00:20

To see the full list of topics, visit the Customer Success Hub.

00:26

Take a moment to read over the safe harbor statement.

00:28

This is a reminder that we may make statements

00:30

about future developments.

00:31

These are not intended to be a guarantee,

00:33

but reflect our current expectations and assumptions.

00:38

Before we get started, let me introduce myself.

00:40

My name is Bryson Anderson.

00:41

I'm based out of Utah.

00:43

Been in the IT industry for about 14 years now,

00:45

the last 10 years in the AEC Marketplace,

00:48

working with firms in all aspects of their IT,

00:50

including data management and collaboration for Autodesk

00:53

workflows.

00:56

Welcome to the Autodesk Accelerator.

00:58

Upload and share project models using Autodesk BIM Collaborate

01:00

and BIM Collaborate Pro.

01:03

The objectives for the session are

01:05

learn how to create packages and design collaboration,

01:08

understand how to view other teams packages,

01:10

learn how to consume a package in design collaboration.

01:13

The workflow we're going to follow

01:14

is navigate to design collaboration, create

01:16

a new package on the exchange timeline,

01:18

select sets, models and documents

01:20

to include in the package, click Share,

01:23

view other teams packages, and then consume

01:26

another team's package.

01:28

We'll start by looking at creating a new package.

01:31

This will be the first step in our workflow.

01:35

In Autodesk Docs, use the app switcher

01:37

to change to design collaboration.

01:39

On the Home tab, we're going to hit this little arrow--

01:43

it'll be a down arrow--

01:44

to expand the timeline view out, so

01:46

that we can see all of our different teams

01:49

packages on the exchange timeline.

01:51

To create a new package, we simply

01:54

click the plus sign to create a new package.

01:58

This is the package creation window.

01:59

In the content browser, we can select the sets, models

02:02

and documents we want included to share out in the package.

02:05

The package will have a default name.

02:07

We can click this little pencil icon here

02:09

to change the name of the package.

02:10

Once we've added everything that we want to share out,

02:13

we can click Save down here, and the changes will be saved.

02:16

This hasn't shared the package out yet.

02:18

It's just saved our changes.

02:21

You can use the change visualizations

02:22

tool to visually see changes since the last package was

02:25

shared.

02:26

If this is the first time you've shared a package out,

02:28

there won't be anything to compare it to.

02:30

But as you create subsequent packages

02:32

you can compare and see how this version compares

02:34

to the last version that you shared out.

02:36

Once you're satisfied with the package

02:38

that you've put together, you can

02:39

click the Share button that will then share the package out.

02:42

The share package when will pop up,

02:44

giving you one last time to change the package

02:46

name if you'd like, as well as give the package description.

02:49

When we click that Share button, all data

02:52

that we included within that package

02:54

will be copied to the shared folder location for your team.

02:57

Let's dive into the demonstration

02:58

on creating a package.

03:01

With constant development of BIM projects

03:03

spanning multiple teams, notifying teams

03:05

of critical changes is key for effective collaboration.

03:08

Creating and sharing packages and design collaboration

03:11

allows you to communicate change and exchange information

03:13

at the right time.

03:15

What we're looking at here is the Home tab of the design

03:17

collaboration tool.

03:18

And up here we have what's called the exchange timeline.

03:21

Now, I have it pulled all the way out.

03:23

When you first get to this page, it

03:25

can look like this, completely collapsed, in a semi collapsed

03:29

mode, or brought all the way down.

03:31

In a semi collapsed mode it's going

03:33

to show you your timeline for your team,

03:36

and then the shared timeline for all other combined teams.

03:39

Or you can drop this down and see all teams separately.

03:42

So to create our package we click this plus sign

03:45

on our timeline here.

03:51

And it's going to start gathering up

03:54

all of the files, models, documents, things that

03:57

are inside of our team folder.

03:60

So if we look under sets, under models, under documents,

04:03

it's going to list out everything

04:04

that's in those team folders.

04:08

For this shared package we're going

04:10

to go ahead and share out our main structural Revit model.

04:13

So we'll go ahead and select that we want that model,

04:15

and we'll click Save.

04:17

This tells the package we only want to include this one

04:20

file in this shared package.

04:24

We need to also set a name for our shared

04:27

here, for our shared package.

04:29

We'll change it from structure one

04:36

to something like structure first share, since this

04:38

is our first package share.

04:40

We'll name it whatever we want to name it there.

04:45

Now, we do have an issues tab here.

04:47

So this is more important once we're

04:49

viewing an already created package,

04:51

but it is available when you're creating the package.

04:53

You can see issues here as well.

04:56

Now, one other tool we have is this change visualization tool.

04:60

The change visualization tool gives us

05:02

the ability to compare the current version

05:04

of a model or a file against an older version.

05:07

If we click Show changes, it'll bring us

05:10

into that change visualization.

05:12

In this model, there are not any changes

05:14

since this is our first share.

05:15

So we don't see anything here.

05:17

We can exit out of our changes and go back

05:19

to our content browser.

05:21

If we need to include any other documents,

05:23

or if we want to include any of the models that

05:25

are found in our team folder, we can do that.

05:27

Once we're satisfied with what's included,

05:29

we can go ahead and hit share.

05:31

This gives us one more opportunity

05:33

to change that package name or to add a package description,

05:36

and we can go ahead and click Share,

05:38

and it will finish sharing out our package.

05:42

Now, this is going to do a couple of things.

05:43

If we go look at our timeline here,

05:45

we'll see that new package shared out here.

05:48

But also, if we were to switch back over to Docs,

05:52

and go to our file folder structure, part of the setup

05:56

is selecting where are shared folder is.

05:58

This shared folder, every time a package is shared,

06:00

the contents of that shared folder

06:02

is pushed out to this folder.

06:04

So for example, if we go to the structural shared folder here,

06:08

we'll see here is that structural Revit model.

06:11

And it is in version one, because this is the first time

06:13

we've shared that package out.

06:15

So this is a copy of the structural model

06:18

that is here in version three.

06:20

So this is a shared version.

06:22

So in Revit, if we were linking this file,

06:25

it would stay at this version until another package

06:28

was shared.

06:29

This would become version two.

06:30

We could then reload our links and get those changes.

06:33

Jumping back over to the design collaboration--

06:37

Once we have sufficient changes or we

06:38

need to add more things to our shared folder,

06:40

we can go ahead and create a new package.

06:43

In that new package, if we include that structural model

06:46

Revit model again, it'll be updated to version two.

06:48

If we were to include a new file that

06:50

was not in the first share, it would be at version one.

06:53

So as we create packages and we add things,

06:56

it will add them to that shared folder.

06:58

It will increment their versions as we create new shared folder

07:01

versions.

07:02

So creating a package is that easy.

07:04

Click the plus sign, add what you want to it,

07:07

and go ahead and share it out to your team.

07:09

So now that we have a package shared,

07:11

let's go ahead and look at how we consume those.

07:15

Let's take a look at the next step, view other teams

07:17

packages.

07:19

This will be the second step in our workflow.

07:21

We're going to head back to the design collaboration

07:23

module, the Home tab, looking again at the design

07:26

collaboration timeline.

07:27

We can click this arrow to expand out to the window

07:30

like we see here.

07:31

The exchange timeline visually shows

07:33

us information about different teams and the packages

07:36

they've shared.

07:37

You'll notice that these icons look a little bit different.

07:40

An empty circle, like this one here,

07:42

is a package that's been shared out,

07:43

but your team has not consumed it.

07:45

A filled circle, like this one here,

07:47

means the packages have been shared,

07:49

and your team has consumed it.

07:50

And a square means a model was published to the team folder.

07:53

You may also see an empty circle that's dotted

07:56

around the outside.

07:57

That's a package for your team that has been created,

07:60

but not yet been shared out.

08:02

Hovering over any one of those symbols

08:04

will give some information, including the title

08:06

and the date it was shared.

08:07

If you see a red number, like you see here,

08:10

it indicates that there's more items there.

08:11

If you click on it, it will then zoom in

08:14

and show a closer up view, so you

08:16

can see all the items there.

08:18

To view any of the packages just simply click on it.

08:20

Here, we've clicked on an architectural package,

08:23

and we'll see the contents of it below.

08:25

Just like when we are creating a package,

08:27

we can use the change visualization tool

08:29

to see what's changed since the last time the package was

08:31

published.

08:32

You can also view any of the files that

08:33

have been included in the package,

08:35

and browse through any sheets or views that

08:37

are included in that file.

08:38

You can also set changes to watch on the watch changes tab.

08:41

If you click on the watch changes tab, brings up

08:43

the selection window, you can create a new watch group

08:45

to watch for changes to certain models or parts of the model.

08:48

When viewing changes, you can specifically view changes

08:50

that you're watching for.

08:52

Use the content browser to switch

08:53

between models and other documents that

08:55

are included in the package.

08:56

Once we've taken a look at what's inside the package,

08:58

we can then look at consuming another team's package.

09:00

This will be the final step in our workflow.

09:02

Just like we did when we were viewing the package,

09:04

we'll use the exchange timeline to pick the package

09:07

that we want to view.

09:08

We'll click on it, and come into the package,

09:11

and explore the contents like we did in the last section.

09:14

Once we've decided we want to consume

09:15

the contents of the package, we simply

09:17

click the consume button.

09:18

You'll be given a message that's letting

09:20

you know that you're about to consume the package

09:22

and the contents of it will be moved into your team space.

09:25

If you're Revit links are referencing

09:26

your consumed folder, those Revit links

09:28

will update with the changes from this package.

09:31

Once the package has been consumed,

09:33

the contents of the package are copied

09:34

to the teams consumed folder.

09:37

Any files that already existed will be versioned.

09:39

So for example, if you had a Revit model

09:41

that you were linking to in a consumed folder,

09:43

and you consumed a package, that Revit model would be versioned

09:46

and the links inside your Revit model would be updated.

09:49

Let's take a look at viewing and consuming

09:50

packages in the demonstration.

09:53

Knowing when and what has changed across teams

09:55

is key to effective collaboration.

09:57

Once a team has created and shared a package,

09:59

it appears on the exchange timeline.

10:00

This allows collaborating teams visibility to what has changed

10:03

and to consume those changes.

10:06

So we are in the design collaboration

10:07

module on the Home tab.

10:09

Across the top here, we see our exchange timeline with our team

10:14

and different things that have happened on our timeline,

10:16

as well as the MEP team and the architectural team.

10:19

You'll notice a couple different symbols here.

10:21

This square represents a model that was published.

10:25

So when we published Revit to our team folder,

10:28

we get this little square here.

10:32

The circle is a package.

10:34

So anytime we see a circle, we can tell that's a package.

10:37

Now, you'll notice that there is a solid circle as well

10:40

as these empty circles.

10:42

So what those mean is, if we look at, say, the MEP team

10:46

here, we see a package with an empty circle.

10:48

That empty circle is telling us that we have not

10:50

consumed that package.

10:52

That it's shared out, MEP team has shared that package,

10:56

but the empty circle is telling us that we as a structural team

10:59

have not consumed that package.

11:02

Once you do consume it, it will turn to solid.

11:04

You'll notice on our team, all of our teams

11:07

are solid already, because that's our team folder.

11:10

It's always consumed by us because it's

11:11

in our team folder.

11:13

But our other teams will see that unfilled circle

11:16

until we go ahead and consume the package.

11:19

You'll also see this one here has a number over it.

11:21

When there is a number on it, it means that there's

11:23

multiple items there.

11:25

If you click on it, it will then zoom in.

11:27

We can see zoomed in here.

11:29

Across a few minutes here we had two different publishes.

11:32

When we're zoomed in, if we want to scroll back out,

11:35

we can use this little scroll here

11:38

to change the amount of time that's shown.

11:40

That's back to the view that we were in.

11:42

So we can either click, and it will zoom in,

11:45

or we can manually zoom in and out with this little slide tool

11:48

here at the bottom.

11:49

Let's take a look at one of these packages.

11:51

We'll go with the latest here of the architectural shared

11:53

package.

11:54

We can tell that it is an unfilled circle,

11:56

so we have not yet consumed this package.

11:58

We'll go ahead and click on it.

11:59

Once we click on it, it's going to display

12:01

some of the information below, the sets, model's, issues,

12:04

documents that are related with this specific package,

12:07

as well as the package description.

12:09

We can click Explore to then dive in and start

12:12

looking at what's inside this.

12:15

Over here on the content browser we

12:17

can drill and look at different models or documents on this.

12:20

In this package there is just The one model.

12:22

We've got it here, and we are viewing it.

12:24

A really good way to visualize the change that's

12:26

happened since the last version is to hit this show changes.

12:30

And what it's going to do is it's

12:32

going to compare the model from the last time it was shared

12:35

to this current shared package.

12:37

And it's going to list out some details here.

12:40

It'll show us the number of things that were added,

12:41

things that were moved, things that were modified.

12:44

And it colors them, so that as we scroll into the model here

12:47

we can see there's the item that was removed.

12:50

The yellow is all the objects that were modified.

12:52

The green is ones were added.

12:53

And then we can actually even drill down even further

12:55

and see which disciplines were affected.

12:57

And go ahead and hide out different disciplines.

13:00

We can come down here to our results as flat results

13:03

or as a tree and really visualize

13:06

what's changed in this model.

13:07

This is one of the best ways to quickly dive

13:09

into a model inside of a shared package

13:11

and see what's changed since the last time

13:13

that package was shared.

13:14

When we're done looking at those comparisons,

13:17

we can go ahead and hit exit changes.

13:19

And it will take us back to the model view.

13:21

Now, here in the model view, we have our navigation tools

13:24

across the bottom--

13:26

orbit, pan, fit to view, first person walk through tools,

13:30

zoom, some measure tools.

13:32

We can even do a little bit of sectional analysis,

13:34

so we can cut some sections really easy,

13:36

as well as openness properties window, where

13:39

as we click on elements we can see property

13:41

details for those elements.

13:43

We can also, on our markups tools

13:45

here, we can create an issue.

13:47

So we could drop an issue here and fill those issue details

13:51

out.

13:52

But we can create issues right here

13:54

on a package to help facilitate some of that communication.

13:58

Let's go ahead and close that out.

14:01

If we click on the Issues tab over here,

14:03

it's going to show us that issue we just created.

14:06

This is going to be a list of all the issues

14:08

that were created on this model here inside this package.

14:12

When we're finished viewing, we can

14:13

go ahead and close this out, come back here

14:16

to our main window.

14:18

When we're comfortable with those changes

14:19

and we want to go ahead and consume that package,

14:21

we just click the consume button here.

14:23

It's going to give a message about what's

14:25

going to happen when we consume this package.

14:27

Basically, it's going to copy the contents of this package

14:30

into your consumed folder inside your team space.

14:34

If you're linking to that consumed folder,

14:36

it'll go ahead and update your links.

14:38

So we'll go ahead and click consume.

14:44

If we drop down our exchange timeline here,

14:47

we will see that is now a filled in circle, showing us

14:50

that we consume that package.

14:52

We'll notice right here on the MEP team,

14:53

we've got another package that has not yet been consumed

14:57

that we can go take a look at.

14:58

But let's jump over to docs, and take a look

15:02

at that folder structure.

15:05

So when we consumed that package,

15:07

the consumed folder within our team space

15:10

will be updated with that model.

15:11

And we do see here under consumed

15:13

is an architecture folder with that architectural model,

15:17

and is now in our consumed folder.

15:19

So as we share out packages, they show up here

15:22

in this shared space.

15:23

Then as we consume packages, files

15:26

from those show up in our teams consumed folder.

15:30

Let's jump back to design collaboration.

15:35

Now that we've created, viewed, and consume packages

15:38

in design collaboration, you should

15:40

have a better understanding of how

15:41

to control the exchange of data for better collaboration.

15:44

And with that, thank you for joining us

15:46

at Autodesk Accelerator.

15:47

There's some additional resources available to you.

15:49

On the Customer Success Hub, customersuccess.autodesk.com,

15:53

there's more courses, learning paths,

15:55

recorded coaching sessions, some more live coaching topics.

15:58

There's similar topics to this, as well as

16:00

topics across the entire Autodesk platform.

16:03

That's all available to you on the Customer Success Hub.

16:05

So go check it out.

16:06

And with that, thanks for joining the session

16:08

and have a fantastic day.