Maximizing the Power of Dynamo and Grasshopper for Data Exchange

NAUMAN MYSOREWALA: Hello, everyone. Thank you for joining us, me and Sean, for Maximizing the Power of Dynamo and Grasshopper for Data Exchange. My name is, again, Nauman Mysorewala. I'm the engineering technology manager at Gannett Fleming. And Sean?

SEAN FRUIN: Yeah, I'm Sean Fruin, mechanical product owner.

NAUMAN MYSOREWALA: Yeah, and I have been an Autodesk expert elite since 2014. I've used Autodesk products for the longest time. I love to tinker with the different tools, and that's why I've been wanting to beta test all these Data Exchange connectors. And my learning and Sean's, we are going to present this class for you. And Sean, you want to--

SEAN FRUIN: Yeah, I'm a mechanical engineer. After about two years of doing design, I got bitten by the programming and automation bug. Dynamo was a big part of that journey. So then I did [INAUDIBLE] a little bit. And now, product owner, building tools for mechanical people at IMEG. Also like to tinker, yeah.

NAUMAN MYSOREWALA: So you will typically see these safe harbor where we have our own safe harbor statement, understanding and creating exchanges from Revit, and Rhino, exchange design data using Dynamo for Revit and McNeel, Rhino Grasshopper as well. At this time of this presentation, Dynamo and Grasshopper connectors, even Revit connectors, they are all in beta preview. So there will be kinks. So if something crashes while the presentation is going on, you can blame it to the beta.

So first and foremost, let's get some understanding of what Data Exchange exchanges are. Then we'll talk about how to set up your Autodesk construction cloud environment and how to send using the connectors. We'll build the graph and show you live, how to do the sending from Dynamo to the data exchange and then receiving it in Rhino to Grasshopper, and sending that updated model to Grasshopper and receiving back in Dynamo to Revit.

And last and most, we'll talk about some examples, and Sean has some very cool stuff to show you. So let's talk about data exchanges. So what are those? But before we do that, let's talk about why we are doing this. And most of the time, according to research through Autodesk, they have mentioned that 95 plus percent of the data goes unused in the engineering and construction. So how do we leverage some of those data?

There is a collaboration and data exchange across AEC, but it's fragmented. There is a multitude of authoring tools, viewing tools. And there's a lot of exchange formats, which are mostly file-based. Well, file-based is great, but there is an issue of having a live common data environment where it is automatically processed, the data is. So basically it's a very painful process, as you said, with file. There is a versioning overhead. There is proprietary data that could be exposed and costly transfer burying the storage and everything.

So data exchanges provide a better alternative. It's a standardized collaboration model. It basically efficient data and manipulation. It's a very light object that you can receive the geometry as well as the metadata. And it's the right data at the right time and the right data for the right people, meaning that you can protect your proprietary data. Sean, you want to add something to it.

SEAN FRUIN: Yeah, we just know all the pain points, I guess.

[LAUGHTER]

I've definitely witnessed all these, the collaboration standards. We have an example hitting that. The cost of transfer, how many times-- uploading a huge Revit model. That's fun, right?

NAUMAN MYSOREWALA: Yep, I know--

SEAN FRUIN: And we were just having versioning issues before this with our PowerPoint, fixing some of that stuff. Awesome.

NAUMAN MYSOREWALA: Yep, so why do we want to use exchange? It's simplified interoperability shared data, not files. And within the Autodesk ecosystem, it includes rich data, geometry, parameters. And you can view them on the web easily. There is an audit trail associated with it. There's curated collaboration, meaning that you only send relevant parts of the model to the relevant parties and the data associated with it.

Some of it is automatically regenerated based on when you update your models. And most importantly, it's the common data environment. Everything is all through Autodesk Docs, and the permissions and control remains within the single system. So you want to add something, Sean, here?

SEAN FRUIN: Yeah, it's just a cool idea, right? I guess, in general, it's this idea of almost having one model that's not a huge bulky file, right? And we can share and pull and add and subtract into this cloud information modeling. So yeah, a lot of cool opportunity. And yeah,

[INTERPOSING VOICES]

NAUMAN MYSOREWALA: So what is this-- it's a shared subset of model information. In Autodesk cloud contains graphical and parameter data, automate information sharing process. And it allows you to connect information changes to automate data flows. Basically, let's say I have a model from Revit, partial. I send it to a data exchange, and then the data exchange goes into the cloud in the model browser.

The ecosystem for data exchange, it is growing. There are now custom applications that third parties have written because of the SDK now. When I started this last year there were like three or four connectors. And that was it for my last presentation. Now you can see there is so much more in development or have been already released out in the world.

So the workflow is just, this is a cool slide that I got from Autodesk. It explains a little bit of how the data flows, that take the partial Revit model. It gets sent either to McNeel through Microsoft Power Automate to do other automated workflows, Inventor for shop drawings, and third-party custom apps as well. The key here is sharing curated sets of granular data across app and company boundaries with a high level of trust and control. You decide that the geometry that goes, and you decide who gets access to it.

So let's talk about how to set that up for our environment to make sure it works. Well, first and foremost, you need licenses for Revit, Rhino, BIM Collaborate Pro. Then you need to set up the account. You need to talk about permissions. We'll talk about in detail. We also need the data. Well, it needs to come from an authoring platform. And we need all the connectors that go with it. We'll talk about how to install those.

And the storage, in this case, the common data environment, which is the Autodesk Construction Cloud. And then you can easily make the data flow between the different applications. In this case, we are concentrating on Grasshopper and Dynamo, and we'll talk about a little bit of Power BI at the end.

So permissions, first and foremost, you need account admin to install the Dynamo Grasshopper app for the tenant itself. Then to load data exchanges, the folder where the data exchanges are created in ACC Docs needs view plus download access. And Dynamo and Grasshopper creation will need edit permissions to write the data exchange as well as to update it too. Sean?

SEAN FRUIN: Yeah, so I ran into a problem, right? So actually, I did not have administrator access. So I had to reach out to my BIM manager, and I'm like, hey, can we add these connectors to our project, right? And it adds them across the company. So that was a little bit of a problem. He was concerned about tokens usage and what this would do. What happens if thousands of people start building all these data exchange. And I had to calm him down and explain, hey, right now we're good. Don't worry about it, no token usage. And then he added me activated, and I could go on my way with exploring data exchange some more.

NAUMAN MYSOREWALA: Sean, though, I do want to say, the but part, it's free now, but wait a little later when it goes up and running. Let's see. It will be tokenized somehow.

SEAN FRUIN: I imagine.

NAUMAN MYSOREWALA: Yeah, so connector installs for the desktop. You can download the connectors, but first you need to the data exchange beta site. The QR code is right here. You can scan that and download the-- or go to the website and join the data exchange connectors and public SDK beta. Then you need to download the connectors for Revit, Dynamo, Grasshopper. And you can also download the Rhino. It is not necessary, but the Revit connector and Dynamo connector are necessary. They work in tandem to send the data itself to the data exchanges.

Make sure if you are testing it before and install all the previous versions, then install the latest and greatest. When you are at the feedback side, any of you who haven't gone there before, there are more opportunities. My favorite is the Revit preview project, which gives you the access to Revit before it's released to the general public. But most importantly, it allows you to provide feedback. Same thing with this beta 2. It's the feedback that's important. So connector installs. Basically, you need to go to the Autodesk Construction Cloud app and Installs.

Under the featured app, you can find the data exchange, Dynamo data exchange for Grasshopper. There is one for Rhino as well. You need to enable those and install it into your tenants. Basically, you open the page, click on it, and there is a install button do that. Then there needs to be a data prep. So I'll talk about just a quick run through of how you can send the Revit model directly onto-- as a data exchange through the Revit connector just to give you an idea.

Basically, I have created views in here, which preselected information in it. Then, in publishing settings, I basically add those views to publish when I synchronize to central. And it has to be a collaborative model, definitely. And then publishing is important. I tell people, make sure you publish at the end of the day, no matter what. And then, basically, you can create a data exchange in ACC very, very easily. Or you can create it directly from the Revit plugin.

Two, the benefit of the ACC is it auto updates. As soon as you publish the model, it detects the changes in auto updates in Revit. Plugin you have to manually push the update. So let's do from Revit. Switch to a 3D view, launch the data exchange add-in from the Collaborate tab. Next, click on Plus Create Data Exchange. Select the project and folder for storing the data exchange I have precreated the folder in my project.

And once you click Create, then it asks you to name it as well as select the folder. And then you can say Create Data Exchange, select View, other than current view if you want. Or you can filter also filter elements, the elements that you just want to send. But I have set up my views to the elements that I really want to send anyways. And then click on Data Exchange and boom.

The con, as I mentioned, manual updates, Revit. And elements and parameters, a lot of them are transferred over and as Revit elements too. Then creating the exchange in ACC Docs, basically, switch to the files tool. Click on the model that we have published, and then open the sheets itself, the 3D view. If you hit the three dots, it allows you to create data exchange. And specify the save folder and the name of the-- and click on Create exchange. And boom, it's done.

Now, as soon as it happens, update happens into the project, it updates. I'll show you in a second. And automatic updates, that's the Revit. Elements and parameters are still intact in this case. So if you can see that it's a very quick process. You just-- I update the-- publish the model. So hit the Publish button. And once it's done processing, you will notice that on the data exchanges, they automatically start updating for you. So I think, Sean, you want to talk about the Rhino connector?

SEAN FRUIN: Yeah, sure. So yeah, this is a really cool workflow that was actually developed by the team doing-- building all this stuff behind the scenes, Autodesk team. This is a really good example of taking geometry from Revit where we can use that to drive some type of computation or design inside Rhino. So here, we're doing the part where we just filter down to the stuff that we want, right?

Then we can create our data exchange in Revit. Go through, name it something not too hard. I like the feature of just being able to isolate stuff. You could even get down to isolating stuff, hide element and view everyone's favorite. But you could use something like that to really get granular of what you're trying to share.

All right, so once that data exchange is created and uploaded to the cloud, we can actually pull that in now into Rhino. And then we can use all the powerful, awesome capabilities. So here we are, right? We're navigating through our AEC project folder. Here's a little preview of what's going to come in. And then a couple clicks of a button, we have this geometry now in Revit, right? Some people ask what about Rhino inside Revit? They're different. Again, this is a way to really aggregate the data that you want to send in an audit trail, where Rhino inside's built for a super user that's using both programs.

So you can see this coming from architect going to a fabricator, manufacturer, or something like that, or even a computational designer where he can build different facades and send that geometry back and forth. So there we can see. Now, we have this awesome building where we can even just taking subsets of geometry and put it in and sub it out and do a whole bunch of cool stuff with it. So yeah, a lot of potential there, I think, for iterating over projects, and pretty straightforward.

With a little bit more advanced stuff you can control, I think, what categories are coming in. You can actually exchange parameters and stuff like that. So really cool stuff. And there we have it. So we just took the two-way trip between Revit and Rhino in a very controlled and granular manner.

NAUMAN MYSOREWALA: So the only thing that the issue is basically that the parameters-- the model always comes in as generic model from Rhino.

SEAN FRUIN: That's why we got Dynamo. We could do some tricks there. Will you go back real quick?

NAUMAN MYSOREWALA: That's why we're talking about Dynamo. That's where the power of Dynamo comes in where you can manipulate that.

SEAN FRUIN: Can you go back real quick?

NAUMAN MYSOREWALA: Sure.

SEAN FRUIN: I just really want to hit this point because this is the mechanical geek coming out of me. So what I see as really cool is we can take this drive geometry and build facades with Grasshopper and Rhino, use that stuff. But then could send multiple exchanges through the cloud to Revit. And then Revit has the capabilities with a systems analysis, something I've worked a lot with, is you could very quickly run a full energy simulation with systems analysis.

So what I picture in my dream is being give me a facade A, B, and C. Let's run systems analysis and really get an understanding and something we can show to an owner and maybe even sell that as upscale and more business, right? Go on. Sorry. I just had to get my mechanical [INAUDIBLE].

NAUMAN MYSOREWALA: No, perfect. Thank you so much. So we'll need to build the graph, and I'll show you live. So let's do this. First and foremost, we'll talk about data exchange and Dynamo nodes. There is this load and create exchange. Then we get into the inputs where we receive the data exchange. Depending on the unit, you can specify. Then the DX data, which is the output of the receive, and convert those into parameters and geometry. We can also query the exchange for the information where it's located and the ID of it as well, when it was last updated.

And also, when you get the DX data, you can also filter objects and receive that data after filtering it. And then, if you want to send the data, you have to basically have an exchange. You convert your geometries and parameters into DX data and send it through that. We'll go over that a bit. This is the parameter conversion to DX parameters.

When you install that Dynamo, it also installs another set, what's called Autodesk parameters, which are basically these Forge parameters that data exchanges relies on. And in my book they are very convoluted right now, as it seems. And there may be an easier way down the road to do these, maybe functions and stuff that we can develop. But we'll talk about a little bit more detail about these later. Do you want--

SEAN FRUIN: Yeah, I'll take this one. Yeah, so here I was just trying to illustrate how to actually use these nodes. I know the image above was probably pretty overwhelming. So this is an example of using it. In the blue, we just have, hey, I want to get some geometry from Revit. I'm going to easily select that, and now I have geometry. In the yellow, we have, all right, let's take this geometry and parameters and create a data exchange with it. The part that I want to focus on here is the creating the spec parameters, and this is the part that we both agree is a little convoluted. But I think-- we go in the next slide, blow it up a little bit, we'll be good.

Yeah, so here we are. So first thing is we have this dropdown, and there's multiple dropdowns. And this one there's some stuff on string specs. There's one on measurable parameter specs. This is your airflow, your areas, your volumes, your temperatures. Can you think of one? Whole bunch of them in there. It's also a Boolean one.

So from there, though, we're going to get the spec ID. So again, it's kind of taking a string and now getting something a little bit more backend Revit, Forge heavy. Then, for some reason, we have to go into this spec-by-spec type ID. This gives us what looks like a string. But again, it's something else. And that's the input to this critical node that is data parameters create parameter type.

So now we have the spec, but we also have to add a name for this parameter and then a description for this parameter. So this is a very analogous to creating a shared parameter. From there, we now have all this just to get our type ID, and then we can go ahead and add a value to it. Here we were not creative at all, and we called it panel A.

NAUMAN MYSOREWALA: And that's the data parameter output that goes into--

SEAN FRUIN: That is for creating one data, one parameter. And then that goes in, and we'll show later. You can do a list of parameters, and-- Yeah.

NAUMAN MYSOREWALA: Yep, so here's the quick workflow just wanting to show you the data. I would take the model, extract the information, let's say, the facade, create the data exchange, and then send it to the ACC Cloud. Once that, then you use Grasshopper to receive it and into Rhino if you want to. Or you can modify it in Grasshopper directly. And let's say I updated the facade. I push it back out as a data exchange and then receive it back into Revit through Dynamo and assign it a category. So that's the overall workflow.

What I'm going to show you right now would be to take a mass surface that I created, send it to Rhino. And in Rhino, develop the geometry. I won't be spending time showing the geometry, how it's done. But I have that. And then send it back into Revit and assign it a category and the material in Revit. So here's the demo. We'll talk about this.

So next step is this, how to send the exchange. And we'll be looking at this in the project. And to do this, let's build this graph in Dynamo. Let's see. We can switch to Revit, and then we have our Dynamo running as well. I'll start a new node here, the new graph or workspace. It's empty right now. So first and foremost, we need to do is get the element from Revit, which is this right there, the surface mass.

So to do that, all I need is the category, so category. I have been making a lot of mistakes with this, with selecting this categories by mistake. And it blows up the graph, and I bang my head trying to figure out. But then I realize this is coming from Autodesk parameters, the Forge category, not a Revit category. So I'll put that in here. I'll show you a little bit later what the Dynamo nodes are for the data exchange in a second.

Let's see. So I need the mass. So select mass. Get that mass. Now I need all elements of category. I really like the search All Element. [INAUDIBLE] subcategory right there. That's connected. I like to group these a little bit to help me understand a little bit better and clarity for others. So this is element selection-- if I couldn't spell it. And I usually like to categorize my group styles, which is the inputs right there. And then what I need to do is convert these elements into the raw geometry. And to do that, we need another node called element.faces right there. That will extract that.

So I connect this elements to element. And then when I run this, if you notice, I have a list of two surfaces, the first surface and the second surface that is coming through. Once we have this, we can talk about some data exchange parameters that we need for creation. We'll need them at the end, but I want to at least show you where they are. This is the data exchange under add-ons.

There is two dropdowns here, data exchange, which is the get exchange. You need that node for every graph you do to work with exchanges. So I'm going to grab that. It allows you to load it from the cloud or create it in the cloud. And basically, this nodes give you a little bit more information about the exchange if you want to. And then I can connect this like that. And the output you can get the name and stuff.

The other part of it is this DX data. So this is where you receive the geometry, send the geometry with it. So I'll click on the send node and set it right here and connect this exchange to the send exchange. And set making sure-- I need to set this to foot because that's where my model is. It used to be only metric, but now they have enhanced it and allowed most all units in data exchanges. So I'll just group this out a bit and, again, call it Create Data Exchange.

And once I do that-- I need to, again, I'm like a little neat freak here. So I'll just make it that. And then I'll add this to the same group right there. So now I have the geometry, but I don't have the parameters. So we need another node from DX data right there. That is basically bigeometries and parameters.

So what this node does for you is converts the geometry and parameters into DX data. Notice these are not Revit parameters. These are the data parameters that Sean showed you earlier. What we need is connect this surface to the geometries. Now comes the little harder part where we need to extract the name of the object, basically, the mark that we'll talk about how to do that.

And to achieve that, I'm just going to create a string first with the name of the parameter that I need. And let's call it mark, and like that. And then what I need is another node called parameter.parameterbyname. Add that node right here. And what we do is we need to connect the name right here to this and then the output of the element right here into this node.

So I will freeze this here for the time being so we don't get errors right now. Try to run now and see what the output is of this. So it says, oh, there is the mark facade. It generates a list. We're not done yet. We have a lot more to go because we need another node called parameter spec type. I'm pulling the parameter spec type from the element automatically. So depending on whichever parameter you do, it allows you to easily pull that information directly from the object. What I need is called spec type right there. And this one, what I do is connect this to that parameter.

Now we have the spec type. So what do we do with the spec type? Well, we need the Forge ID of that spec type. So Forge.typeID. Thanks, Sean, for helping me with these because it was very confusing. So I connect this to a Forge type. Now we have a string. I don't know why it's called string, but it is. Trust me. Some of the naming is confusing.

SEAN FRUIN: I don't know why either.

NAUMAN MYSOREWALA: [INAUDIBLE].

[LAUGHTER]

Spec.byspectypeID right there. Now, we take this string output to this type ID. I have no idea why it's called string, and then we get the spec. This is what we need, as Sean was showing you earlier. So we need now to create a parameter itself. The name of the parameter is a shared parameter. So if we're doing that, we need a data parameter.createparameterbytype. So we need the name. But we have the name already, actually, right there in my screen. I'll just move it here just to clarify, make it easy. I'll correct the name here. I need a description and the spec. Well, the spec goes like that, easy, now.

And then read only is optional and then the description. So for a description, again, I'll just get a string and call it-- now we have that, and feed it to the description. Now, let's try to run this and see make sure the graph is working. Yes, we didn't get any errors. It just gives you this Dynamo parameter name, something something. Well, I'm going to now, again, group these guys-- oops, wrong one. This and select these, and I'll call it parameter processing.

And I'm just going to group style this under Actions. And then, once I have this, now I can take this not yet because we need another parameter, convert this and give it the value of that parameter. To do that, I'm going to use another one called Data Parameter. Oops. DataParameter.bytypeID. Oh, no, not that one. Sorry. DataParameter--

SEAN FRUIN: I can just now wait until someone in the Dynamo community takes over what we're doing right now and just smushes it inside of a node, whether it's a Python node or a custom node. I will--

NAUMAN MYSOREWALA: Yeah.

SEAN FRUIN: If that's not done by Revit 2025 in AU, in 2024 I will do it and put it in my Dynamo package.

NAUMAN MYSOREWALA: Yeah, so string, type ID, and the value of this is going to come from the value of the parameter right there. We have extracted this parameter value, which I need to still use a node called Parameter Value. Yeah, I know it gets a little bit-- parameter.value. Woo! Man, my brain is fried at this point, OK?

SEAN FRUIN: Yeah, that's another thing to note too on this, right? You do this once, and it's repeatable. So you won't-- build the system out.

NAUMAN MYSOREWALA: I think-- yeah.

SEAN FRUIN: It should be a little bit easier, but yeah, it's not ideal.

NAUMAN MYSOREWALA: Yeah, and now, I want my parameter to push, hey, whoop de doo.

SEAN FRUIN: Yay!

NAUMAN MYSOREWALA: Yes. OK.

SEAN FRUIN: Fingers crossed, let's run it.

NAUMAN MYSOREWALA: Huh?

SEAN FRUIN: I said, fingers crossed. Let's run it. Yay.

NAUMAN MYSOREWALA: Yep, cross my fingers. OK, so now I can take the DX data that was converted into the node of that. But before we run this, we need to make sure that we create a parameter of data exchange in the cloud. I can select the folder right here, and then I'll call it [INAUDIBLE] DH1 and say Create Data Exchange. This just creates that placeholder I talked about.

Now, before you press Run, you need to click on Send and then hit the Run. So now it is going to send it. While it's sending it, basically, it's taking the geometry, taking the data, and pushing it into the cloud. We can see that progress as well. Notice that we have-- oh, it's still waiting for it. So once this goes through, we'll get a little bit of-- depending on the complexity of the geometry and the data and everything, this may take time.

So while this is running, let's switch to Grasshopper and Rhino. So in Rhino, what I need to do first is to start with a new template. This template I need is-- since I send it in foot, so I'll do a large-- right there, large objects feet, open. And now have the template ready, and I start the Grasshopper. I have this graph preloaded just to show you where all the data exchange nodes are. These are the conversion nodes, baking, and all that here. Exchange info, get exchange.

So these are basically the same as in Revit with a little bit different flair to it. There are a little bit more convert to parameters from DX data. It has a little bit more enhanced outputs from it and makes it easy to convert the data parameters as well. And then there are filter still, convert to geometry from the DX data. If you want to make the geometry in Rhino you have to bake it. I love that term. And then you can convert the geometry parameters to DX data and send it out.

So I will start a new document. And with that, I will start receiving the information. To do that, I need the get exchange node always. The next one I need is the receipt, which is right here. And then if I want, I can click on the info one as well. Where is that one? Right there. So basically, this goes into right here. The result of this also goes here. We can see what the information has.

Then, once we start receiving it, what we need to do is convert the DX data into geometries. So the node that we need is convert to geometries right there. And then the next one we need is convert to parameters as well, DX data and convert it to parameters. And so we connect the output of this receive node to the DX data right there. Once that is done, I'm going to just create a panel here just to see what's coming in. I'll just do the parameter like that, parameter keys. I hold the Shift key to add multiple nodes right here. And once we run that, we'll see how it goes.

Then what we also need is Convert to geometry. So what does that mean? Well, we got the geometry and everything. Let's run the node. But before we do that-- well, it's automatically running, sorry, in the background. I'll say Load. Hopefully, you will be presented with the dialog box soon, if it doesn't crash. So next what we want to do is load the data exchange from Revit that will send through. Oh, great. Oh, boy.

So I have a premade-- this is the beta that is causing that issue. We'll just continue this at this point, and then we'll try to bake this automatically right there. So the next node we need is the baking node right there, and place that, so the geometry. And next we take the parameters and put that in here. And then we click on bake. So this is the basic graph that we have.

When we load it, for some reason, it's not working for me. And it's OK, I'm going to save this. And I'll open up another of my file here that has the information imported in. So the information that came in was basically right there. That's the surface I got. I basically took that and placed some fins on top of it. So right there, that's the geometry I quickly created right there.

And now what I need to do is send this information into the cloud back again. So to do that, again, I will have to do is create a data exchange from Rhino itself and go from there. So I need to launch Grasshopper again. Start with a new document. And I'll just walk you through the process because I know it is-- some reason, it's not working. So what I need to do next is send this panels to a data exchange so Revit can receive it through Dynamo.

So let me launch Grasshopper. And let's start with a new document right here. I'm going to test the first thing here and make sure that this routine is working and whether I can do that or not. And it is not going to cooperate with us right now. I don't know what the deal is. It was working fine before, but I will show you the results and everything. And I'll show you how to build that graph that we need itself.

So we need the graph for sending and receiving. So this, I'll put it at the end. The next item I need is to select the geometry. I just used a simple geometry right there and grab all the solids using the BREP. To do that, what I need to do is first I need to click on Set multiple BREPs. And this allows me to select directly from the-- there is a geometry pipeline too I can use, but I just need to select the solids. And now this BREP has-- if you notice, that it says 15 locally defined.

Now, I need also the data exchange. And we need to convert the geometry and parameters. So we need that. So right here, it's convert to geometries. This is convert parameters. The next one is to send is the plus sign right there, DX data. So right there, we'll put that DX data right here because we need it at the end. First, we need to work with the geometry itself. We have the geometry, the solids from the BREPs right there. Well, B REP, sorry. And we connected to geometry.

The parameters are another item right there that we need to deal with. We also need another one called Send the DX data and Create the data exchange. So the result of this load needs to go under exchange. And right here, I need to connect this data right there into this send node.

Now, let's talk about parameters. So first and foremost, what I need to do is get a set of lists that I need to send. Basically, it's an index list right there. What I need is to do is this mark ID and the fin is my prefix. And I'll combine it to automatically mark 1, 2, 3, 4, 5, 6, 7, 8. And then it orders it automatically. So we'll create that. And to do that we'll just use a List length, list length. The list length will take this BREP right there and put it in the length. And then next we need to generate a series out of it.

So we'll create that series. The series allows us to give the count for 15 of them right there. Next, I need a panel node. And I need to do is there-- it says multiline data. I'm going to turn that off and say draw paths is turned on and draw indices is turned on right there. I can add my information here, mark, which is the parameter name, and then fin, which is the initial--

So once I have this, I need another one called longest list. The longest list will give us-- and it will combine it together for us. So I'll put this mark fin and add it to the list A of this and this series out to list B. Then we need to review the-- we'll use this create statistics node and connect-- we just need to use the list A output here. We don't need any other ones. And then we have to get another node for series. So I'll do that, and then connect the count to the count node of the series.

At this point, we have the output coming through. But at the end of the day, we need to concatenate the mark and fin together. So to do that, let me put a panel here so we can see the output of this. And we need the other node called Concatenate. And would take this and put it in fragment B. And then we take the list A output, longest list output to fragment A and then connect this to that. So we get the list right there, but it won't work. Every one of them will be called fin zero. Then the problem is, what I forgot to do is I need to switch this to graph. Once I do that, I need to also switch this to graph.

Now I have the list correctly generated for me, and we take that result and dump it into parameters. So once I have this, I can create the exchange in the cloud and then hit the Send button to send it. It's not working, but we'll show you the results that we did it earlier. So Grasshopper to Dynamo, I just did that earlier for you. So this is what I was sending it out. And the receiving of the Dynamo was basically this one. So I sent the object from Dynamo to the surface. So this was my surface that I had sent right there. So that's that.

So next step now I need to work in Revit again. So I'll go back in here and launch my Revit again. I had some issues, so I had to restart it again. So I'll hurry this up since we are short on time. I'll just load up the Dynamo graph itself, so right there. So I'm waiting for the Dynamo to load. What I need to do is now receive the exchange from Grasshopper back into Revit and convert it into that.

So to do that, let's quickly review the graph that I need for it. So I need to load the data exchange. Then I need to basically receive it and convert DX data to geometry and then DX data to parameters. We'll process the parameters, define the material category, and we'll convert them to Revit walls.

And so right there, I'll load this one to show you how this works. Oh, not this one. So I'm going to just show you the graph that I made for receiving the data exchange. So first, what I need to do is load it from data exchanges. Yay, it worked this time, for Dynamo at least. It gives you the page to load it right here. And what I need to do is get the fins from-- we can preview those. And those are it. Click on Load.

So that received it, but now we need to receive that data. But before we do that, we need to set this to foot and click. We can click on Receive. Now, once I do that, I need to run that. And it's going to receive the information from-- and it built those information right there. Now, I am getting an error, and it says, ah, the category. So as I told you earlier, I mess up all the time where this category is not the right category that I want. Categories, I need to make sure that these are the Revit one, the icon like this. Now I can select walls.

SEAN FRUIN: You did that on purpose.

NAUMAN MYSOREWALA: Hmm?

SEAN FRUIN: I said, you did that on purpose.

NAUMAN MYSOREWALA: Yeah, I did because I wanted to show people this is a constant one that I run into with the parameter, once this Autodesk parameters gets loaded. So I'll do a run again. And whoop de do. Now we have our fins into Revit placed automatically. Now, let's go to a realistic view. And you see the realistic view. Hey, Nauman, I need to hide those. And the way you do it is basically under graphic display options. But you need to uncheck the Show Edges and hit Apply. And hit OK, and no more. Boom.

I hope this helps understand how the workflow works for you. If I select one of these, it says walls. You can see that. So hope you liked it. Hey, let's go back to our presentation again and keep going with the show.

There are other workflows you can do. The Autodesk did a very good demo for food for Rhino, where they sent support points and then built a canopy and parameters and an inventor. They brought it in and [INAUDIBLE] to analyze it. So we did the Grasshopper demo. Now, Sean, we'll talk about connect and analyzing our data. So you want to go?

SEAN FRUIN: Yeah, sure. So I always like to do a fun example that someone can always relate to. So this first example is going to look at building a golf simulator with Dynamo. So first off, I'm not good at golf. Last time I played golf, I took my friend's really expensive driver, and it went farther than the ball out on the grass and had to tell everybody to stop. So I'm like this guy, not very good at golf. But I am good at computation. So I was at the friend's after built, and we were in line for the new Star Wars ride, the Millennium Falcon ride. And of course, long lines at Disney. We get a little bored. And he says, hey, check out this top secret, super cool Revit model.

And right? So pretty cool technology now, through Autodesk Construction Cloud, you can pull it up right on this phone in line for Disney, right? So a couple years goes by, and I get selected for this class. And again, trying to think of a cool, fun idea. And I thought, hey, I remember that top secret model. So I said, hey, can I borrow-- can I use that top secret model? And he's like, what? No way. What's that? I tell him, hey, go look up the exchange. He reads that he can protect his IP because, again, this is a top secret Revit model. And I say thanks, and we built this example together.

Yeah, so from there he takes his top secret Revit model. He uses Dynamo to place flags at all the flag locations in the model and place the little T geometry at all the teeing off locations. He makes a data exchange for that, uploads it to AEC clouds. I then take that data exchange with the Dynamo sandbox free to everybody, load that data exchange, and then send it off to generative design to build our golf simulator and our hole-in-one robot.