Capitalizing on Additive Manufacturing Using Autodesk Generative Design

DANIEL: Welcome, everyone. My name's Daniel. I'm a engineer and I work in the Autodesk advanced consulting group. I think we'll get straight into it. Hopefully you guys have seen the learning objectives for this. What we want to look at is-- you all have heard about Autodesk Generative Design, the new product.

So we want to look at a typical workflow that you might use with that to actually make a real product. And then we're going to look at how that performs. So we're going to look at setting up the obstacle and starting geometry. We're going to go through, we're going to use AGD to redesign the bracket. And we're going to use Fusion 360 to do both linear and non-linear validation on that design.

And then after that, basically we're going to have a look at a bit of a correlation of comparison between the designed original bracket and the generative design new bracket. OK. Just a quick introduction to the original GrabCAD challenge. This has been around for a while-- I think probably about a year and a half now. But basically, the target was to mass optimize the bracket you see under the load conditions on the right. So there are three pretty straightforward cases-- a horizontal load, a 45 degree load, and a vertical load.

The original specifications for this problem said that it needs to be a steel with a modulus of 200 gigapascals and a yield strength of 100 megapascals. So this is the GrabCAD challenge. Our goals are a little bit different-- it wasn't to win the GrabCAD challenge. What we wanted to do with this is we wanted to redesign a bracket using a requirements only specification.

So we didn't want to say we want to topology optimize that bracket. We wanted to redefine the way that we did it. We then wanted to explore the solution space of various designs. So we can get insights as to other potential designs that we could use for that. And then finally, we want to verify the design with Nastran and Fusion 360. Now, that would be a very detailed femme.

As an appendix to that, we then basically wanted to go through and prove out the manufacturer-- show that these things can be built. Finally, we validate that using a physical test. So as I said, we didn't set out to win the GrabCAD challenge, so we needed to adapt the requirements to suit the problem that we actually have here.

So first of all, that steel-- the precipitation hardened stainless steel-- very, very strong. With the test equipment we have, it didn't make sense to actually have something that needed to be loaded so much before it broke. So what we decided to do is switch it to aluminum. And that makes it cheaper as well.

Now, because the aluminum and the steel have a different yield strength, we need to change these requirements. Because we want to see some kind of significant optimization of the mass of the bracket. So these loads, we essentially just scale them down according to the ratio of the yield strengths.

And the last two things that we did-- so we changed the space envelope. We didn't want to constrain ourselves to designing within the space of the bracket itself. What this did is this allows us for a much better design exploration. It gives us more options that we can look at. As you can see, the yellow area is where we extended it. But the area underneath the bracket is still not allowed.

And finally, a simple thing is the spherical bearing. Because it's a in-service part it's got a spherical bearing. Which is completely necessary, but for the purposes of testing the bracket, it's not necessary. So we're going to get right into how we actually set up these generative design problem. And this is going to start off with how we use Fusion to achieve this.

So I've got a little video here-- this is going to show you the geometry-- I'll scale that guy. This is going to show you just the basic geometry set up that we need to do. These are all very basic concepts. But what it's showing is actually how easy this is achieved in Fusion. So we've got the original bracket there, and we literally just created a sketch surface. And we're projecting the curves of the original geometry to the base of the bracket.

We can then go forward, we can select these profiles and extrude them to a suitable length. Now you might notice that obviously, this is going to form part of the structure-- the interfaces of the structure when we go into AGD. So the next thing we want to look at is the load pin and actually, keep out zones.

So here we project the geometry to the midplane. We go through and complete our sketch profile. You can see the particular features that would be somewhat more difficult to sketch, we've projected those. And then we can just quickly create the profile that we need.

So what you see here now, once we extrude this, this becomes obstacle geometry. Something that we tell AGD that you can't use that space, needs to keep out. And the last bit here, this is another bit of keep out geometry that we're going to look at. As you can imagine, there's structure that's going to attach to this. And so you need to make sure that we isolate the space around that, so that the system knows that we need to leave space for a load on-- something that's actually going to apply the load to the lug.

So I'm going to move on from this video-- we go on a little bit. But essentially, we generated all this geometry quite quickly. And that's just starting with the original bracket. And we've just picked out curves, extruded bits and pieces. That's all we need as an input space for AGD. So at the end of this process, we're going to export that design as a standard CAD file. In this case, we'll use the SAT file.

And we go forward, and we import this into AGD. So I just want to give you a quick look at the process of doing this. So we're creating a new project here, importing new geometry, importing the SAT file. You can see, we're specifying what we want each of those pieces of geometry to be. So that's our starting shape in yellow. We're now specifying the obstacle geometry.

And then finally, the geometry that we wish to preserve. So this geometry is always going to be present no matter what the design is. Next step is to apply a few loads and constraints. So we're constraining the bodies of the interfaces there. And next, we're going to apply a constraint in the y direction of the lug, because that's going to be constrained by a load on.

And finally, we apply our load to the lug. And that's applied directly to the surface. And you can see, you can quickly create several load cases. And we change those as necessary.

Next up, we want to specify actually what the objectives of the analysis is going to be. So in this case, it's quite simply minimize mass. And then together with that, we apply some certain constraints. In this case it was manufacturing. We looked at applying an unrestricted constraint, so the geometry can grow however it likes. And we also apply an additive constraint, which says it can only grow in the z direction shown.

On top of that, we specify a few different materials for it, so it can explore and do a design of experiments with these different materials. So we create our project. Now basically, we just hit generate. So we've just defined all of these constraints, we've just given it to the system. And you can see there that-- I think it was about 28 different results we expect to see.

So now we've got our various designs, you can browse through them quite easily. And you've got a nice little preview of each. Now, you can sort these out by various categories. You can see this is now sorted by material. And we can look at a plot of those various designs. And you can see on this plot, we've got max von Mises stress versus mass there. And so you can quickly isolate the best performing designs.

You can see, we just pointed out one of the lowest stress and one of the lowest mass selections. And you can see that the colors there actually also denote the material, so you can sort it out in that manner too. So here's one of our candidate designs. And we can then download that and save out our mesh. And there's another design that you wanted to use. Again, it's the same kind of thing-- you can see it's quickly viewable.

All right. So now we have these new designs. Obviously, behind the scenes there is some kind of analysis that's going on there. And it is optimizing the structure. So you've got your various constraints. It's making sure everything meets that, and it's allowing you to explore it.

For the next phase, obviously you get something at the end of that. And as every engineer, you need to make those fine tuned changes to the structure. And you need to make sure it's going to work for whatever you're using it for. So in this case, we validate it using a linear static stress simulation. So I just want to give you a bit of a overview of the workflow that we use for this. Because one of the key steps in this is actually converting it to BREP. So we take-- basically, from AGD we get a triangulated surface match-- an STL-- something that you could dirctly 3D print if you wanted.

From that, there's a process that we use, and we actually use Autodesk ReMake. We convert that to a quad mesh, which looks for a quad flow. That outputs a OBJ file, which contains quad mesh. The next step is to actually convert it to a T-Spline in Fusion 360. Once we've got that T-Spline, we can very easily convert that to just a natural BREP file.

So a couple of other auxiliary steps-- this is quite key for many kinds of designs where you have very high tolerance interfaces. And one of the main things is to reinstate those interfaces. So what you get out of the design is something, yes, can be additive manufactured. But you need higher tolerances then you can achieve on the additive design with those key interfaces.

All right. So you can see in the middle here, we've got the interfaces reinstated, we've got our holes, we got machine surfaces. Now it's ready for a simulation. So this file here is our CAD surface representation of the final product that we intend to use. Using our Fusion simulation, we can then take that and apply a very detailed finite element mesh to it.

So the question is, why verify? Why are we performing this step? Shouldn't we just get the right thing out of AGD and just be done with it? Well, as I mentioned, you've got differences in the interfaces is one. But there are also subtle differences in geometry, and they come about as a process of that BREP conversion. So that makes this validation step very important.

Now that we've got this detailed model as well, we can then go forward and do various kinds of simulation that we couldn't initially do. So these ones that are not yet incorporated. So we're looking at nonlinear simulations, buckling, and thermal analyzes-- just some examples. So I'm going to go forward now into the verification of case two. As you remember, that's the 45 degree case.

I'm going to do case two and case three first. Because case one was the one that we actually tested to failure. So I just want to show you the linear validation first. So we looked at this, and we did verification against the nominal yield strength of the part, and assessed this.

Now as you can see, we do actually see the yield strength, but it's very localized. So it's something that you can make a judgment about as to whether you want to live with this. Or if you wanted to be very stringent, you could actually go back and say, you know what, I want to go back to AGD and up the safety factor.

So for case three, we had a fairly similar thing. But this is quite interesting. This really highlights why we do this validation. Because the sharp edges that we've created to reinstate the interfaces have actually given rise to some local stress concentrations. So we've had to remove some material there, and it's resulted in this. Again, it's very, very localized, and it's up to the engineer to judge of whether that might just be stress singularity because of bad mesh or something like that, or whether it's actually something that they can expect.

So just a few tips if you're doing this kind of verification. So with a linear analysis, they're usually very conservative. Because it doesn't allow for any stress redistribution. Once you pass the proportional limit of the material, i.e. It goes beyond the linear range, it allows for some redistribution. So you're not necessarily going to get significant yield in the areas that we just highlighted.

However, if you're looking at using in-service parts, you've got to consider increasing the size of the attached interfaces. That will allow you a bit more fat to make sure that you can achieve a certain safety factor. And again, if you don't want any yield whatsoever and you need to be ultra conservative, then you would just go back to AGD and up the safety factor.

And another important thing here is we need to make sure that your material properties accurately represent what you're actually going to get as built. That's very, very important in the case of additive, because your book values don't always match the values you get. And that's for various reasons.

All right. So we'll go forward into how we approach this in looking at the non-linear static stress simulation. So this is going beyond, and seeing if we can load this thing and understand how it really is going to fail under a quasi static load. So a couple of things with the materials-- with this, we've actually tested both the subtractive and the additive variants.

So with the subtractive there, you can see the material properties. We've got an expected modulus for aluminum. But the yield strength is a lot higher than the additive yield strength there. Likewise with the ultimate strength. But another thing to notice is that actually, these two values are very close together. So not long after yield, you're going to probably get ultimate failure with this.

Now these specimens, we took these from the materials that we used for the final test. And we actually tested a number of specimens, developed the stress strain curves, and used those in our analyzes. Another important note there is you can see the difference in the xy and the z orientations of the additive, [INAUDIBLE]. And this is actually pretty good given most materials. Generally, you'd see a much bigger deviation of these two printing directions-- the specimens.

All right. Caution on material properties. As I mentioned, the properties are going to deviate from the datasheet properties. And again, especially in the case of additive. So we've got to be aware of the differences due to our printing orientation, our grain direction, heat treatments, et cetera.

When you're doing your verification simulations, use conservative properties. Don't go in there, for example, using b-basis values or optimistic properties. Make sure you get just the minimum-- gives you a bit more fat in the analysis. And in the absence of that, get sufficient material data via test. So actually get the full test properties of those.

All right. So a brief little demo of the capabilities of Fusion simulation. So we're jumping into the sim environment here. And we're creating a nonlinear static stress study. Now just a note that this is actually still in tech preview mode. So you can see, we quite rapidly apply our loads and constraints. In this case, we want to generate quite a fine mesh.

So now is the interesting bit. This is the most important bit if you want to actually have non-linear material behavior. And you need to specify this in Fusion with the entire material curve. So you go beyond just the elastic modulus and [INAUDIBLE] ratio. We need a full stress strain curve as we saw in the previous slide.

So it's quite easy. You can actually see we've got our stress strain values listed here. And you can get them in a CSV file, and just import them directly into Fusion. And there we have it. So there's our material curve. We basically get on with that, and hit simulate. So I'm going to jump forward now just to our results inspection, just so we can actually see that and how we interrogate these non-linear results.

So key thing to note-- see the step bar there. So we've got 10 load steps in this. In this case, they're all even increments. So you can actually view your results for all of those load steps. And you can shift through that slider very easily. And one of the really powerful things with this is it automatically interpolates between load steps for you. So we can look at our safety factor here. You can see we can isolate critical areas.

We can then go forward and visualize things like displacement, stress, et cetera. So in this case, we're going to actually-- to actually collect information about the load displacement curve. We're just putting a probe on the surface there, which is going to track the displacement. And we can take those values, and look at that against the load. So then that will give us some validation data if we do test this. So we can see the displacement there as it changes with the load step.

All right. Now for the fun part. So we've done our validation, our verification. And it's time to actually build this and see how it performs against that. So we go through the make phase. And here's your traditional design, and you can see it's 302.8 grams. And we go to our generative design, which is 83.7. And that's actually 28% of the original mass. Now obviously, the design space has been increased for this. But that's still a pretty awesome weight saving compared to the original design.

Now, we've got the AM parts and the original parts here, which I'd like to pass around. Sorry, not those ones, Mark. Yeah, they're the ones. So you've actually got three specimens that you'll see. There's a subtractive original bracket, which we machined in AMF in Birmingham. And there's-- yep, that's right. There's a unconstrained one, which is the one you see on the screen. And then there's another one, which actually has the vertical build constraint.

So while the unconstrained is actually buildable in this case, but it did need supports, whereas the one with the y build direction didn't need any supports.

AUDIENCE: Looks like a giraffe drinking water.

DANIEL: All right. So a bit now about those interfaces. So there's some important bits on this where you need those high tolerances. And you can see, you've got the head of the screw where it seats the bolt holes, you've got various mating interfaces, the load pinhole. So all of these interfaces needed to be machined.

This gives you a bit of a look at what the test setup was. And you can see the importance of those interfaces in this case. I've got a bit of a diagram there of the various components, so you can get an understanding of how it's actually been tested there. So if you're looking upwards, you've got your bracket load pin, which goes into the load arm. Now that load arm there is connected to our load self or our test machine. And this fixture here actually allows us to test in each direction. So we can just rotate about the axis of the bracket load pin, and test it in various directions.

OK. So the fun bit here now. So here's the original bracket. This is us loading it to failure with the horizontal load case. So this is greatly sped up. And you can see that we have a really rapid crack, and it happens right at that small stress concentrated area. And there's an image of the failure there.

So we've actually got the failed specimens here. So I'm going to pass these around. But I'll just warn everybody, there are some sharp edges on it. So just be very careful. So having a look at the results I retrieved from those-- the first thing we noticed was actually, there was really poor elongation to failure. It only displaced just under five mils before it failed. Pretty good load at fracture-- about 8 kilonewtons nearly.

So if we look at the material ultimate strength there, at 451 megapascals. A way of actually trying to remove the influence of the material, and just looking at comparing the shape for a like for like strength, we've done this little technique where we'll normalize the ultimate strength to 500 megapascals. And then basically scale what that failure load was.

And we're going to do the same thing again with the generative design bracket to get a comparative normalized load at fracture. So in this case it's about 8,500 newtons. All right. So let's go and have a look now at the generative design bracket. So immediately you'll see how much more this has displaced. It's a lot more ductile. And the failure isn't immediately catastrophic. It doesn't go through the whole structure and tear it apart. And that's what the failure looks like there.

So what this tells us is actually the load redistribution in this shape of bracket is much, much better. So let's have a look at the load curve for that. So you can see, that stretches out all the way to about 12 millimeters there. So very, very good elongation to failure. These kind of structures, you can actually predict the behavior a lot better. It's going to be a lot less sudden.

The load at fracture is a little bit less than the previous one. But if you look at the material ultimate strength, it's only 265 megapascals. So when we normalize this, you get a over 10 killonewton normalized load at fracture. And that's 24% better than the original.

So looking at cases two and three, with these we actually just did a test in the linear range. So we didn't actually take this all the way to failure. And these tests, they didn't damage the specimens and we could take some easy linear measurements. You can see for load case two, there was a little bit of a reduction in the stiffness. It was around about 10%. And for case three, it was about equal.

So the next step with this was to actually go forward and take our results, take a load displacement curve and see how we can correlate those to the software, and see how well our Nastran nonlinear solution actually predicts that behavior. We basically take those measures, as I mentioned, at the pin location.

A point to make on this, is the nonlinear static simulation, that does not predict the actual fracture. That will tell you what the load curve looks like. But when it gets to the failure point, it would just be a smooth curve. There's no drop off as you see these clips on the curves.

As you can see though, the correlation is especially good. So just so you know, these load curves were generated using test specimens from the same material that we made the brackets out of. That data was put into our Nastran nonlinear solution. And we simulated, and then we correlated them. So we've got good agreement there.

So let's have a little bit of look at the details. For the original bracket, you can see we've got an ultimate strength of about 477 megapascals. And an interesting thing to look at is, where does it first exceed the ultimate strength? And that was at about 3,400 newtons. And then we look at the final fracture-- the von Mises stress-- to see how widespread the failure is. And that was about 7700 newtons. And you can see that this quite clearly correlates with where the failure occurred.

So some key metrics that we take from this. First of all, we've got the onset of plasticity. That's the point at where you start to see a significant amount of plastic strain. For that, it was about 3,100 newtons. And you can see not long after, the crack initiated at 3,400 newtons. A final fracture at 7700, and it was a very small distance-- only 3.1 millimeters from the initial crack to the final fracture. So that's the distance measured on the curve here.

So if you look at the correlating results on the GD bracket-- bearing in mind again, this is a lower ultimate strength, that 265 megapascals. The first exceedence of the ultimate load was actually at 4,300. Which even though it's of a weaker material, it's still higher than the previous one. But the stress at the final load, you can see it's predicting precisely where we got our crack.

So looking at those key results and how they actually compare to the initial bracket. The onset of plasticity was actually a lot earlier. But that's expected because of the material properties. The initiation of the crack was, at load, 26% higher than that of the original bracket.

The final fracture, obviously again, lower. But that is because of the material properties. But the interesting thing with this is that from your initial crack to your final failure you had 152% gain. So that distance basically allows you to monitor the structure. Let's say you had this in a service environment and you wanted to see the beginnings of a crack. That tells you that actually with this, it's a much more safe structure.

So again, I mentioned one technique of just identifying the efficiency in the shape itself before, and that was normalizing the ultimate load. Now that we have these simulations, which are quite reliable-- we've looked at the correlated results, so we're quite happy that we can get a reasonable result from them-- what we do is we can take that, and we can basically take our original material and we can put that into the simulation of the GD bracket.

So in this, what you see here, is now material specific comparison. So these are the curves from two nonlinear simulations, which both use exactly the same material curve. So it allows you to make that assumption that both structures have completely the same material. And with this you can see that whichever way you look at it, the generative design bracket is actually superior. So the original bracket in this study begins to yield at 1,175 newtons. Whereas the GD bracket begins at 1,600, which is a 36% improvement. But if you're looking at the curves, you can see the GD bracket is stiffer, it's stronger, and it's more ductile.

So the conclusions from this study. First of all, we looked at how to rapidly generate many designs with AGD and select the one that we wanted. So we've gone through and we've verified the design using Fusion 360 simulation tools. We found that the original bracket obviously used a much stronger material, but the GD bracket had a superior what we call shape efficiency and ductility. So 30% higher load for plasticity in the like-for-like material, a 24% improvement on the normalized failure load at ultimate, and it was only 28% of the original mass.

So just to a point, if this was to be used in service, what we'd definitely say about this is your additive material should be actually of a much higher quality than we've built this one here for our laboratory test. And you can actually get material powders that will much more closely resemble the actual properties of your monolithic machine aluminum.

All right. So thanks very much. I'll take some questions. Yeah.

AUDIENCE: You didn't give any kind of mesh size when you start to the [INAUDIBLE]

DANIEL: OK. So you're asking, how do we control the mesh size during the optimization in--

AUDIENCE: I guess, you use some kind of a [INAUDIBLE] minimum mesh size or maximum mesh size.

DANIEL: Yeah. OK. So do we have a minimum or maximum mesh size? If we're talking about the validation, there's--

AUDIENCE: [INAUDIBLE]

DANIEL: Oh, starting with the-- yeah. So inside AGD then, you basically just-- we can choose to have a difference in accuracy. That's kind of done behind the scenes. But you have a level of accuracy in which you want to go for your shape, and that's correlated to the mesh size. Yeah.

So in this case, it was just set as a nominal value. And we look at our designs and then we go through and do the validation. Yeah. Any other questions? I saw somebody else had their hand up. Yeah.

AUDIENCE: The simulation that you did, that was a full [INAUDIBLE] simulation for a predicted result based on machine learning.

DANIEL: Sorry. Can you repeat that?

AUDIENCE: The simulation you're doing now is using the Fusion 360. The full simulation-- I saw a talk yesterday, they talked about using deep learning to predict simulation results to understand what you're doing. This is a regular, conventional simulation.

DANIEL: OK. So are we using deep learning to actually predict these results? These results were manually correlated. Yeah. So the results that you see here is just-- one is our test and one is our simulation result using the material curve as an input. Yeah.

AUDIENCE: So in AGD, is there essentially a setting to determine the number of different solutions that it's generating in essentially, the resolutions being done?

DANIEL: Yeah. So you're saying, can we choose a resolution to say, yeah, I want to see more designs in between certain parameters, et cetera? Is that what you sort of--

AUDIENCE: Yeah. How's that determined?

DANIEL: Yeah. So initially you're going to get a population which is based on the number of different combinations that you can get with material build direction and safety factor. If you want to actually go into a bit more detail and look at the designs in between, you could look at doing separate studies where you change your level of accuracy.

But ideally, the best way would just be put some new properties-- material properties in and shift those. Or maybe choose a different safety factor that you want to achieve with that. Because then you can just say, all right, it's got 50% left in it at a 1.5 factor. Or maybe you want to add a bit more, however it may be. And you could specify those, and then just generate the whole lot.

Any more questions? Yeah.

AUDIENCE: Those of us who don't necessarily have access to testing the equipment, do you have any recommendations for how to figure out the material properties of the [INAUDIBLE]?

DANIEL: Right. So if you can't test the material, how are we supposed to do this analysis? Well, you've got different ways of obtaining the material curves. So first of all, you've got your book values. And there are some common rules that you can get from typical handbooks, like Mill handbook, and you can actually characterize the [INAUDIBLE] good curve. And that will give you your stress strain curve.

So what I'd recommend with that is, because it's not completely tested data, is you want to go in and you want to get your most conservative values-- put in the most conservative material curve that you can. And that will give you an idea of how it's going to behave. Being conservative, you know then that what you simulate is more than likely going to be OK in reality. Yeah.

AUDIENCE: How do you know if those curves are being generated with the new [INAUDIBLE] materials as they come out? Is it a stress training--

DANIEL: Do I know if the material providers are actually generating those curves for us? Is that what you're saying?

AUDIENCE: Yeah.

DANIEL: So unfortunately, with most material suppliers, they don't release stress strain curves. Because it can be very dependent on what you're actually testing. So they will give you ballpark values. If you look at some of the [INAUDIBLE] properties, they test their properties using a certain kind of dog bone. But they still don't give you the stress strain curve.

There's a lot of data in that. And it's very hard to give you something that's very accurate, just because you're as delivered material or whatever you print can vary from that. It's not necessarily going to be exactly the same.

AUDIENCE: [INAUDIBLE] to characterize a lot of these [INAUDIBLE] materials and equipment [INAUDIBLE].

DANIEL: Yeah, so talk to Doug if you want to know a bit more about our materials database and how we're actually doing that. Yeah.

AUDIENCE: Can you talk a little bit about the algorithm used to generate the designs-- how it works and how long it takes to run these?

DANIEL: Yeah. So it's something that we run on a cloud. And it's just a genetic algorithm that will do a number of designs of experiments. But there's a bit more to it than just that, in the sense that we actually got level set optimizations. So that differs to your typical topology optimization.

And that's what allows you to have these nice, smooth curves in the part that you get out of that. So in the optimization, it is a genetic algorithm. That's for the DOE. And then you've got-- in some routines there is a gradient based optimization as well. Yep.

AUDIENCE: If you arrive at a design like this, and then go back a few steps and only model something that very closely resembles that through more traditional methods, and feed that into the basis, do you get optimizations that just aren't worth it-- that are a few percent? Or [INAUDIBLE] algorithms go off in other directions? If we took that final part and modeled it [INAUDIBLE] then that's the basis--

DANIEL: Right. So it sounds like-- if we got our result from AGD, we've exported that. Then let's say if we take that and we design something that's very similar to that, and we take that and we use that as a starting basis going back into AGD. What's going to happen then? Well, the chances are that it's probably going to converge onto the same result.

One thing is because you're starting with something-- and it sounds like you're describing something that's more of a topology optimization. You're not going to get a good design space. You've taken the exploration aspect out of it. So from that, yeah, you could try that. But you would converge on the same result, for one. And you wouldn't be able to see anything else in the design space. OK.

AUDIENCE: Is this [INAUDIBLE]?

DANIEL: I'll have to direct your question to Doug.

DOUG: So our design isn't what we call [INAUDIBLE]. So we've released it to specific customers. But specifically, [INAUDIBLE]. We'll be rolling out to more of you soon. There's an announcement that comes out tomorrow.

If you're interested in trying it out, go to the [INAUDIBLE], which is across the hall [INAUDIBLE] That's kind of [INAUDIBLE]. And you can just get dirty and [INAUDIBLE] and try it out. If you're really interested in joining the [INAUDIBLE], sign up and we'll get a screening [INAUDIBLE]

DANIEL: All right. Anybody else? No? OK. Thanks very much, everybody. Hope you enjoyed it.