All the Skeletons in the Closet: Skeletal Modeling Master Class

Welcome to All the Skeletons in the Closet, a Skeleton Modeling Master Class. In this class, we'll be going through the skeleton modeling methodology from start to the end.

About myself, the speaker, I'm Ben Cornelius. I'm originally from the UK, where I did a Bachelor of Science in product design, where I started using Inventor in the early 2000s. I've used Inventor in Vault in industry ever since, starting in the aerospace industry, working on aircraft interiors. Then I moved to Canada, where I worked for an Autodesk reseller, helping customers conduct technical support, training, setup, installation, and services whether in house or on site.

I was then creating configurations for the mining industry. I now work for Dynamic Attractions, Dynamic Structures, starting as a senior lead CAD modeler and CAD admin, now as the PLM-PDM-CAD Systems Manager, where I take care of the day-to-day running of the various CAD-related systems. In my spare time, I'm either snowboarding, walking my dog, on the idea station or beta forum.

JAMES COLLINS: Thanks, Ben. I am James Collins, originally from Australia, where I completed a mechanical drafting apprenticeship with a sawmilling equipment manufacturer. During that time, I started using Inventor about 2005 and saw how magical 3D design could be. After completing my apprenticeship, I worked in various industries from materials handling to minerals processing and started using Vault at the same time.

I was then transferred to Canada in 2012 to head up the drafting team, where I started using iLogic and saw how powerful a tool it was. I now work at Dynamic Structures/Attractions as CAD/PDM administrator. In my spare time, I can be found snowboarding, kiteboarding, running, taking photos, or painting.

So what we do at Dynamic Structures-- as you can see in the picture on the right, that's a large telescope enclosure that we've worked on, the TMT. And we have a number of other telescopes that we also worked on listed there. We also do a lot of other complex structures.

And then, on the other side of things, Dynamic Attractions, we do dark rides, theaters, coasters, custom attractions, and parts and services. So pretty interesting stuff. And on the right, you can see one of our fly-in theaters.

So to start off, it's worth talking a bit about creating intelligence and design intent in your design when doing skeletal modeling. So here you can see a very basic way of doing that is essentially we're trying to, in this particular part, say, let's make the width half of the length. So essentially you can see there d1 equals d0 over 2. And if you start off simple with something like this, then you can obviously build on that. And we'll go through more down the track. And then back to you, Ben.

BEN CORNELIUS: Thanks, James. So why skeleton modeling? We looked at, as James mentioned, intelligence within a part. How do we incorporate intelligence inside assemblies, and how do we make parts talk to one another? So let's look at the different adaptive methodologies.

Starting with skeletal modeling, it's a top-down methodology. So in other words, you be placing some of or all the geometry needed within one or multiple subskeletons. That geometry would then be derived out into part files, and then the parts can be created from that.

The pros of this methodology-- part files therefore have common geometry between the different parts. The constraining can be quicker and easier because those original parts are created in correct coordinate space. The skeleton itself can be used for constraining-- kind of reuse parts within the assembly. It is a very stable and also you can get very repeatable results with this. You're also capturing the design intent. So in other words, if you did a bottom-up approach modeling the individual parts and then assembling them together, it'd be easier to control, say, the overall size with a skeleton versus a bottom-up approach.

The cons-- it has centralized geometry files. These will be sensitive to deletion and changes and also the file itself being removed. It can not always be clear when others are making changes. We will look at that and address that throughout the presentation.

Other methodologies-- solid body modeling, it's similar in that you'll be putting the sketches within one or multiple files. The main difference here is that you will be filling them with features. And each part is represented by a solid body.

The pros-- here, again, you'd have that common geometry. Again, it could be quicker and easier to constrain because you have those parts in the correct coordinate space. It is a little bit more visual than skeleton because you do have the features in there. It could be good for breaking complex plastic parts.

But the cons on this-- again, some of the cons are the same. You have a centralized geometry file. Again, that's a sensitive file to deletion and change. Again, it could not always be clear to others when making changes. But you'd not necessarily have any geometry for constraining reused parts in that methodology.

The geometry file is also extremely performance heavy. Because you're not only putting the sketches in that file, but you're also putting all the features in that file as well. There's also an overriding urge to sketch on faces of features, and this will create more dependencies. Instead, it's more optimal to reduce them to make the file more stable. Therefore, moving features within the model browser can be very difficult because it's a history-based system. The part itself will contain no features. If the link is broken, effectively it's like looking at a STEP file.

Other methodologies-- adaptivity. It is bottom up. How that would be adaptive is, for example, you could take several parts, place them within an assembly, and then start projecting geometry from one part to the other. The cons of that is that it is unstable. It doesn't work well with many parts.

It can prevent constraining. There's no real advantage on the constraining side. And there's no common geometry but just a projected link. It can be, however, good for the purposes and application of hoses and cabling.

And then, lastly, a middle-out approach. So in other words, you could take an engine block, derive that into a file, and then start building another part off of that. It would be a bit more visual than skeletal modeling. But again, the parts are dependent on the original faces and features. There's, again, a centralized geometry file, which would be sensitive to deletion and change. And there wouldn't really be any geometry for constraining reused parts in the assemblies. Over to James.

JAMES COLLINS: Thanks, Ben. Now we'll take a look at our skeletal modeling methodology. Now that we've seen that skeletal modeling is our methodology of choice, we'll show you a couple of examples of that.

So on the left there you can see we've created a bunch of sketches, basically everything that we needed to be able to create the parts for that particular frame. And when that starts to get too complex and you need to break it down even more, then you can take that and derive it into another sketch and further define more detail in a subskeleton if need be. So you're not forced just to put it all in one sketch. You can break it down and break it out.

So as far as how you go about doing that, basically we start a new part. As per usual, you hit Create. And then, when you have that part open, you go to the Manage tab. Under the Insert section, go to the Derive button, and that will allow you to go and then select that skeletal model.

And we can hit Open, and then we can choose what we want to include in that drive. So in this case, you can see what we've included there in a couple of the sketches. We've also turned off the associativity so that it's not updating to the master or whatever design view you have selected.

And then we hit OK. Then, over on the right, you can see the final product after you have created your features. All right, back to Ben.

BEN CORNELIUS: OK. Thanks, James. Next, we're going to go through some guidelines and recommendations for skeletal modeling. Just some basic kind of dos and don'ts. So first of all, when you start a skeleton sketch, we would recommend that you do not commit a main sketch to an origin plane.

So this is a fixed reference which can be good for some applications. But if you require that plane to move later on, it's not going to. Then you would have to redefine that sketch to a different work plane. That could have adverse reactions downstream. So in conclusion, we would advise using a custom work plane instead where possible.

OK, plane creation-- so on the right there, you can see work planes being offset one from another. Really, the issue here is that you are creating more dependencies firstly. Also you can't visually see the dimensions between them like you can on the left there. Also, because of those dependencies, if you delete one earlier on, you're going to delete the subsequent ones.

Ultimately, what happens, as well, is you can see it gets busy. So you turn those work planes off, and then it's not always clear where those planes are or how those sketches were created. On the left, it's more preferred to create a line, a sketch with points, and then create the work planes from that. So there's no dependencies between one work plane and another, and it's clearer and more visual to make changes.

OK. So when creating profiles, you may have instances where one is butted up against another. Sometimes you'll see people, for instance on the right there, would just draw a rectangle and then just simply put a line through it. The issue with that is that you may come along later and need to separate the two, but they aren't actually two separate profiles. So the good practice here is whenever you have a profile to draw it as a separate profile. That way it's easier to come along later and then separate them if needed.

Other guidelines-- sketches should always be fully constrained, otherwise you will have adverse reactions when making changes. Do not delete geometry unless you explicitly know the downstream effect, as this could destroy part features and assembly constraints. Be dimensionally dominant over sketch constraint dominant. So we will go over that later.

Avoid projecting projections. So again, you will be creating more dependencies, when really the goal is the opposite-- it's to reduce them. Do not project work axes or work plane. The length is not really controlled, and it will effectively be very messy, and you'll have large projections throughout your skeleton.

Recommend to keep a view representation that is clean. E.g. that means to us no work features on or sketch dimensions. Otherwise, it does get very, very busy, very messy. It's difficult for other users to use it and even yourself.

Recommend not to use patterns or mirroring within sketches. This is better suited to features within the path. For example, you could pattern some sketches and use that geometry, you may come back and reduce the pattern count, and that will obviously be destructive.

Do not use solids in skeletal modeling. As it says, it's skeletal modeling. And if you start using solids, it's effectively like a solid body modeling. There are certain instances, very complex situations, where surfaces may be needed, but generally they are pretty few.

Try to use lines instead of points where possible. If you're using points everywhere, it can be difficult to see where they're coming from, especially if they're projected, and also, in general, to see kind of what's going on. Limit the amount within a sketch. Try and break it up as much as possible.

Sometimes this is not clear when people start with this methodology. If you put too much into one sketch, it can become difficult to control. Also, you have to bear in mind that when you derive that sketch into another file, you can make the smallest change that doesn't pertain to that part geometry, but that part will still want to update.

Limit the number of sketches within the skeleton. Personally, I've found around 300. Obviously this will depend on what you're actually modeling, but that's kind of a rough guideline.

Do not put lines on top of lines where possible. So don't keep putting, as I say, lines on top of lines. Try and reduce that as much as possible. It will get confusing.

Do not use chamfers or fillets within the sketch. We found that's better suited as feature at the end of the part file. Also, I would avoid using project cut edges or 3D intersections. There are cases for it-- advanced cases-- but in general work points for intersections is best.

I would avoid using 3D sketches where possible. 2D sketches are more stable, easier to control. Even using a 3D sketch, I would opt to use 2D sketches to control them. So back to James.

JAMES COLLINS: All right. Thanks, Ben. Now I'm going to take a look at our skeletal modeling naming convention. And we'll start off with the skeletal file itself.

So you can see there on the left we have the product project number prefix, followed by SK for sketch, and then an open 18 character limit that we use as a descriptor. And we control the scheme with a default numbering scheme. And if we were to step into that file and have a look at the browse and node naming, we'll start off with the skeletal non iFeature sketches.

So these, we have an SK prefix and then a sequential number, followed by an optional suffix, an optional additional suffix, and then the work plane in which that sketch resides. And this and all the other browser node renaming is done with automation through our iLogic external triggers, which we'll see in this next page here as well. So now we'll take a look at the skeletal iFeature sketches.

So we can see, very similarly, it has a sketch number, sequential number there as well, the iFeature number, and then the member size of that iFeature, as well as the work plane on which that resides. And Ben will talk a bit more about iFeatures later. But basically, any time that we change that iFeature size, this member size will also update. So that's all automated.

As far as the part file sketch naming goes, we have the sketch number at the front followed by a dash. So that kind of differentiates the two there between, say, the actual part file and the actual skeleton file. That dash is meant to be a visual differentiator there. And you'll see that furthermore on the next page.

And yes, there we have that, we have the optional suffix, and then the work plane that it resides. And then, very similarly, here we have the work planes for both the skeleton and part. And you can see the dash differentiates those two so the end user can easily see what they're working on. It's going to be obvious, but that helps too. And so, all of these are controlled with iLogic automation.

All right. So now on to parameter naming. Basically, we wouldn't recommend naming every single parameter, unless you're doing a configurator, because it's extremely time consuming and hard to enforce and hard to get people to do it all the same way. So we recommend using user parameters instead. And when you do use a user parameter over a sketch dimension, they're a lot less likely to be deleted. And that's obviously less likely to cause downstream issues with the files that consume those parameters.

And when you do use those user parameters to define critical dimensions, make sure that you give them a good name, something that people who are consuming them will know what it is. Because there's nothing worse than seeing d1, 2, 3, 4, and not really knowing what it's supposed to be driving and why it's critical. All right. Back to you, Ben.

BEN CORNELIUS: Thanks, James. So I'm going to go through our skeleton template-- so we actually have one-- and what automation is on that template. So first of all, the BOM structure is set to phantom. This is so it doesn't show up on the parts list and people haven't got to remember to keep changing that. The user parameter, lists out the material sizes, which this is convenient and causes fewer downstream errors. So you can see the material size and then the user parameter name.

I've also made these key as well. So the key can be filtered off. So if you didn't want to see all those material sizes, along with your additional user parameters, you could do so.

The other automation that we have-- we do utilize external iLogic rules, and we have those on the document. So we have this iLogic trigger here before Save Document, and we have some iLogic rules there. So first up, we've got the clean default. So we have a default view representation. So every time it saves it's going to turn off everything except the sketches. That's what default view means to us for a skeleton file.

Next up, we've got nothing visible for derive. So that turns everything off. The purpose of that is that it can be quicker and easier than turning everything off with the icon there that's in the red bounding box.

And then we have a working view representation, and that's just user defined. There's no automation attached to that. So it's up to the user how they use that view representation.

We have renamed sketches to iFeature descriptions. So it renames the sketches associated to the iFeature. They have the iFeature name, also the size, and then the work plane. So if you look in the screenshot of the model browser, we have an abbreviated name in the beginning.

The next rule, initial rename sketches for [INAUDIBLE] work features, it will give you a dialogue when you first save. And then you can opt to put in a default suffix. That goes to an iproperty, and you can change that value at any time.

On the part template, I'm not going to go through all of these because we're going to go more into depth in a class later in the week. But I just want to point out that we do have this skeleton iFeature description to part description. So it pushes the iFeature-- any parts created with iFeatures, it pushes the material size or description to the iproperties.

So the need for a structural modeling system-- as you noticed, we've mentioned iFeatures several times. So I'm going to explain why. So ultimately we found, for structural modeling, we needed the size of the shape within the skeleton file itself. This is because the shape or the size of that shape actually drives the shape and size of the connection. So we opted to create each type of structural member and then combine all the sizes, as many as possible, within those iFeatures. And they're table driven, so you can pick different size and change them.

We have an iLogic set of tools. We have many iLogic rules. Initially we used the iLogic browser. It did take up a lot of real estate, and you couldn't tailor it per environment. So we use an app from the AppStore. We put all the most commonly used or most useful rules on the browser on the ribbon there. And then the ones in the red box are the ones that are more pertaining to our structural modeling. And quite a lot of them were done or inspired whilst working on the TMT project that we'll go over later.

OK. Time to demonstrate skeletal modeling. So I'll be heading over to Inventor. OK. Now we're in Inventor.

So this is an example of a skeletal model. So this is a maintenance platform that was used for a roller coaster. So I'm going to go through this skeleton file.

So first up, I'm going to move the end of part marker. So I'm going to cheat a little bit and just roll through this skeleton and then explain the different steps. So highlighted here, as I mentioned earlier, you have to start sketching on an origin plane. So we've just defined a line here that we'll define for a custom work plane to start on.

So there I've created the custom work plane. So next I've defined this rectangle that would define where the columns will come for this platform. Obviously, how you start will differ based on what you're modeling.

As we mentioned previously, we have the overall dimensions listed. So that would be the column length and column width for example if I turn on the dimensions here. So I've linked this to some user parameters.

So next up would be to create the work plane that comes here. There are several ways of creating a work plane. So I'm going to head over to a demonstration of that.

OK. So if I right-click and say Show Inputs, you can see this was created by clicking this line and this point of this line. But there is a more optimal way to do this. So, for instance, if I edit this sketch, and change this parameter, and then finish this, you can see that it hasn't then followed this line.

So it would be better to select this line and then say the work plane it was drawn on. That way it will always follow that line. So you need to think about things changing-- things that could change at any point. Just don't think about this is the design at this stage.

OK. So you create this plane, and then you would continue doing the construction geometry. I'm just going to hide work features. This is going to make it clearer to see the sketches.

So you would continue with the construction geometry. So these lines could represent the neutral axis of the member. It could also represent, say, the edge of the member. And I would recommend doing that when it's on the outside of an envelope so you can fully define that envelope.

But previously I talked about being dimensionally dominant over sketch constraint dominant. So I'm going to open up a demonstration for that. If I go into the sketch, we have two examples. One's sketched constraint dominant. One's dimensionally dominant.

So say I had two profiles and I now wanted to separate these. Now, I've got to turn on these sketch constraints. Now, I've got to go hunt down and find how this was actually constrained. Maybe there was a coinciding constraint here. And then maybe delete that.

But straight away I've picked the wrong one. Now, I've broken the geometry. This generally leads to frustration. You end up deleting geometry, which could have now a downstream effect to the parts that are using this geometry.

Versus if you're more dimensionally dominant, if I want to separate these I simply change a dimension. It's possible that it flips the wrong way. We do have a set of on our tools is this flip rule. And then, yes, it's the correct orientation.

And then, also for the sizes, we've got dimensions, one linked to the other. This can be a lot clearer than, again, using the sketch constraints. So I'm going to head back to the skeleton file.

So next, I'll move it to the next step that would be done. So I'm going to move to the end of part marker. So you would then place on lines to represent the different members, the lengths of the members. At this point the lengths are just arbitrary. The reason for that is that we need to have a line there to therefore place a work plane, and then a work plane to place the member on, and then we can, when creating the connections, access the size of that member.

So you would carry on adding these member sketches. So that's completely filled. One note here is that if I right-click, and say Show Input, you can see there I've opted to create a vertical work plane. And therefore I can then adjust this line up and down.

This is going to sit below the total frame because there's going to be some grating that goes on top. So therefore, it's not necessarily wise to put all this in one single plane. You want to allow for change again. Also, we want to move the line versus moving the shape. And we can see that a little bit later.

OK. So now that we've filled this with the member lines, we now have to look at work plane creation. So we can click the line and click the end of the point. So there is this Repeat command on right-click. It's not that intuitive, but it is there.

Other ways of doing this-- we do have some automation whereby I could just pick the line and then pick the next line and carry on. So it does take one click out of the equation. But still a bit time consuming, so we do have a further rule whereby I could select a sketch or multiple sketches and simply just say Add Work Points to the end of all those lines. And there we go. I can do that and undo that. I've got single transaction, so that would just undo.

So now that we've gone through the work planes, we'd now need to place iFeatures on the end of them. So first of all, I'll show you out of the box how to do that. So we're going to do a channel, we can pick a work plane, and then we can go ahead and change the size of that.

So you would need to go in the sketch, project the end of that line, and then position that sketch. I'm going to show you a couple of other ways of doing this. But we have-- it's going to preselect these work planes, and then we're going to do insert multiple.

We preselected. We're going to pick the channel. And then you can, again, choose the size. So that does speed things up. But again, you still have to spend the time to position each one of those features.

So I'm going to remove these and then we'll show you one final way that we have of doing that that will incorporate the position as well at the same time. So again, we're going to go for channel. Yes, we want to-- all the dimensions will be set to 0. We're going to select the work plane. Again, we're going to go ahead and choose the size.

So do we want to rotate it? No, it's in the right position. So select a line to make parallel and dimension width. So what does that mean? So in other words, what it's done is that, because we picked that work plane, it's finding the relationships, the inputs, to create that work plane. So therefore it's finding this line.

It's therefore editing that sketch, putting a line perpendicular. And then, therefore, we can make it parallel and then dimension it to 0 on that line there. So obviously, in cases where not everything is always going to be flat or square, that's why that's needed.

OK. So we positioned one. And then we could keep going. So we're going to do another one.

No, I don't want to rotate. It's fine again. And pick that line. So, no, we're good with that.

OK. So now that we've looked at placing the iFeatures, what about changing the size of them? So out of the box we can just edit an iFeature and simply just change the size of that. So you can see that that's changed size. Let's just undo that. We do have a facility as well to change multiple. So there's many cases where we need to change lots of members at the same time.

And there we go. OK. So the next thing would be to just continue adding these. So we're going to remove these here, and then you would keep just adding these iFeatures in so that you would get to every single one, every unique part has an iFeature.

Obviously, if you know you're going to use this channel in this location, there's not much value in placing additional ones in. So now that we've done that, we need to look at the connections. So I'm going to go ahead and open a connection demonstration.

And here's one I've started. So the order, obviously, we did the construction geometry, we did the member sketches, and we placed the iFeatures on. So now we've got the connection there. But the order that it's going to end up in is actually going to be construction geometry, the connections, the members, then the shape sizes.

So in other words, we're going to have to move this above the members, because the length of the members is going to be dictated by the connection. But the connection itself, it's size and shape is dictated by the size of the members. So you have some options here where you want to edit this. In other words, if I wanted to edit in this location, you could, but you'd have to be very careful of the projections that were made.

We do have a rule to help with projections. So I'm going to run this now. Say that we wanted to project this line. So in other words, how do we know for sure that we're projecting the original construction line, not a projection from another sketch?

So this will give you more information. Rather than the traditional Select Other, it's going to tell you, well, is that line construction or not, is it projected, and what sketch is that actually from. So we could try the first one. It's going to also highlight to further kind of tell you which one that is visually.

So we're going to pick the next one. And that's the correct one. So yes. No. So now we're going to actually look at moving it and doing it that way.

So I'm going to go ahead and select this sketch. So we've got a rule to help move things. Because you'll find when you're just dragging it on the browser they can suddenly shoot up or shoot down. This rule makes it a lot easier to move things. We don't want a new marker, and we're going to go ahead and pick above these members.

OK. So now we have our sketch here. If I now go into this sketch, you can see, well, because it's above these members, we can just see the construction geometry. We can go and project with confidence that we are projecting the right lines. Then we can make these representations of the member parallel to these projected lines.

So you can see that the shape is starting to be shifted, a little bit changed because of, again, the lines dictating the shape, as well as the size. So we're going to change the size next. We will also need to dimension to this line, because that's going to be the neutral axis of that angle.

I'm going to come out to show you the next part. And then I'm going to turn this with the sketch dimensions on. So then the idea would be to find out, well, which iFeature is which. So this is l25, so you go ahead and change this. I mean, I've already selected this previously and I know which letter is which. So I know that is the overall size, and I know this is the neutral axis.

So the idea then would be to continue linking this to the members. So once you've done that, you will have a fully constrained connection. The next step would be to edit the member sketches. You can then project this representation of the member, and then you can go ahead and make that line-- now it's length is dictated by the connection.

OK. Once you've done that, we need to create the thickness side of the plate. So we have a rule for that. And you can just simply click the line of that plate. We're going to say Non-Centered. We're going to Pick from user parameters. We're going to say 6 mil plate.

It's possible, though, again, it could go to the wrong side. Again, we may need to go back and use our flip rule. And then Finish. So you could then offset this member based on the dimension of this plate because this angle was welded to this plate.

OK. Now we've done that, I'm going to go back to our main skeleton. And then the next thing I want to show you is on sketch 113. We have a intersection, and I mentioned that earlier. So I do have a demo file for intersections as well-- so how to deal with intersections.

OK. So what I have seen some people do, where they have an intersection-- say a line that's going through a work plane-- they tend to just click the line. But that's not really what it's doing. It's just projecting the start and end points of that line. So I can demonstrate that by go ahead and changing that there.

So the way to deal with that is if I create a work point, click the plane, and click the line. It's then going to generate that work point. I throw that up before that sketch. Let's go in. Another advantage here is I can just pick the work point from the browser, and then I finish. Another advantage is that you could redefine that work point to a different plane or different line if you so wish.

OK. So now that we've been through that, let's go through back to our main skeleton. And then, once we've done that, we're going to go to default view [INAUDIBLE]. Because we would continue and move this to the end end, this end of part marker. So obviously, we would continue creating these connections, and then moving them up above the member sketches, and then changing the lengths of the members so that they are the correct length.

So next, we want to look at creating parts. James, in the PowerPoint, did show you kind of an out-of-the-box methodology of starting a new file, deriving through the skeleton, and then picking the entities needed. The only thing there is that it is quite time consuming to do it that way. You could use the Create Part feature. Again, the only issue there is if you're choosing sketches from the browser, how do you know which sketch is which? You really need to pick from the graphics window.

So the next rule is just that. So there's a Create Derive here. So we can just pick what we actually want to bring through. Yes. And then we can just Escape when done.

And then it would bring through the entities, and then you can create the features. So what if you then forgot to bring something through or the design changed and you need additional entities? That's what this button does right here. Again, this will allow you to select multiple sketches.

And then it will go back and then just add them in. So this can be a lot quicker and easier than editing the derived component. Although it will go back, it's going to be difficult, where you can't really choose more than one sketch at a time.

OK. So we've looked at that one way of creating parts. What other ways or how else can we automatically generate parts? So the next way of doing that for the structural members that we've created-- I'm going to select these iFeatures. So we do have something called Create Steel Parts. No, we don't want to add any additional entities to each one of those. Yes, we're going to place it in a new assembly.

We're going to pick the assembly template. We choose the part template. So what it's now doing is it's automatically generating the structural members because we've defined all the inputs needed within the skeleton file. So now you can see it's not only generating these, it's placed the skeleton within the assembly file, and now it's placing these parts within the assembly file for us as well.

OK. Once that's done, you can see that it's generated those parts, placed them inside the assembly. So if I expand one of these, it's actually flushed these to the origin because they're in correct coordinate space. So the other thing you can see is if I right-click on the iproperties it's also pushed in the description of that member as well.

OK. So next up, I'm going to open up a version that's already been saved to disk. So we have that there. So how do we constrain reused members?

So we also have a tool for that. If we didn't, it is painful to do this. So let's say I want to place a new one. I want to choose that member, select other. Let's just make sure you've got the right line.

So it's going to just make a presumption. And then it gives you the dialogue of "is this the correct size?" So this is no. Is it the right way around-- so the planar rotation. So no.

And then, is this the correct end? So in this case, no, it's not. And then, it's done. And then you can select the next line to constrain this in. So that's our rule for constraining reused members.

So next, what we did show you-- or sorry, I showed you-- how to change the size of multiple members within skeleton file. But we also do have a rule to change the member size itself by picking a component or multiple components. And then I can say change size of member. And then I can scroll down and then pick a size. Let's pick something that is going to be larger.

Let's go for this one. There we go. So the size is a bit comical, but it's to clearly show you that it has changed size. So those members may come from different skeletons, but it doesn't matter. You can change as many different components there.

OK. So next is creating a plate. So I did show you that Create Derive. We do also have a different rule for creating a plate. So let's go ahead and create this plate.

Do I want to add bolt holes? So yes. We just have one bolt hole pattern. And then we can create that part.

OK. So we're going to head back to that assembly file. I'm going to constrain one end that's already been saved to disk. We do have various place rules. So we use one of those, and it's going to constrain that in.

And then, what if I want to reuse that piece of plate? So let's go ahead and drag it in. So to explain this, if I'm trying to constrain this, I'm going to constrain it to the skeleton, as I said, for reused components. You could opt to go to the modeling tab, and you could change the view representation, say, to master maybe to get all the sketches on. Or you could expand this in the modeling mode and turn them on. If you're in the modeling mode, you won't be able to see the constraints under the component.

That's fine, I think, if it's just a one-off constraint for one component. But if you're doing it multiple times, that's going to get really tedious. So let's go back to that part [INAUDIBLE].

So you can see that I had a work axes there. So that was created off of the sketch geometry. So if I go back again, the advantage there is that I can see that in the modeling-- sorry, in the assembly mode. So I could go ahead and select that and then go ahead and use that to constrain to the skeleton.

It shares some of the origin constraints in this case. So I'm just going to say Flush to Origin. And then I'm just going to delete the constraints that I don't need. And that's constrained in. OK.

So we've shown creating the plate and reconstraining or reusing that plate. So next we're going to show you how to deal with or how we deal with the cut profiles or copes. So you can see we have one there. So let's open the skeleton.

So right here, let's just go down to the browser. So we have one here. So this is an iFeature as well. So we have the channel shape, and then we have a line to represent the cut or cope as it were.

So if I head back to the assembly file and then I open this component, you can see that I've actually brought that sketch through and used the split tool to remove that material. So that concludes our presentation of skeletal modeling methodology with structural modeling. Hopefully that's been informative and given you some ideas. So back to our PowerPoint presentation.

So I mentioned the TMT project, the 30-meter telescope. So this is a new class of extremely large telescope that's going to allow us to see deeper and observe in space. It's a 30-meter diameter mirror. It's three times as wide. Nine times more area than the current largest telescope. And this gives us unparalleled resolution and gives images much, much sharper than the Hubble Space Telescope.

So when first looking at this project, it's kind of like a Mount Everest to climb to achieve this. Because not only has this project got huge complexity, but it's also got huge amounts of volume. So at the top there, that's the cap and shutter. The turning planes were not perpendicular to the axis. This made all the connections around that turning plane different all the way around.

You can also see, based on the skeletal methodology, if we're putting-- say for the cap we put all that sketch data in one file, that's going to be a huge performance issue. Also, the fact that, as I said, the connections at that turning plane are similar but they're actually different, so we're not going to want to redraw that sketch geometry over and over again. So automation is definitely needed here to complete these deadlines.

So this is how we approached it. So this is one rib, a piece of structure within the cap. So essentially we would create one. We would use that skeleton in a way that it could be the skeleton itself or the plane around the axis could be moved. Therefore, it would update and generate a brand new piece of rib structure.

In the middle there, you can see a Vault copy design. Unfortunately, we won't have time to go through all of the Vault copy design dialogue. There's one example. That's a typical copy. In other words, the first time you do this, you may have that skeletal reference throughout all these components. So you will need to decide which ones you will need to go into change and which ones you need to reuse.

Once you've done that and then created a copy, you can simply right-click, say copy on the skeleton. And then if you have copy direct parents on all the files that need to be copied automatically copy. So we're going to go ahead and give you a very quick demo of this. So back over to Inventor.