Do you ever do top-down design? Of course you do. If your design contains two or more parts, then those parts must be related in some way. Creating parts that fit together is top-down design and it’s the most natural way to design.
Over the years, traditional CAD has added tools for designing parts in the context of an assembly to capture a higher level of design intent. Many of us were sold on the promise (and the demo) of top-down design and how it could eliminate errors, rework, and scrap. We gasped in awe as the assembly was modified and all associated parts and drawings updated. It truly was a miracle!
Well, that was the demo. In reality, if you’re going to use top-down design methods in a traditional CAD system, you had better complete the advanced training course and plan your strategies for dealing with in-context relationships well in advance of starting your project. Why? Because making reckless references to faces, edges, and vertices of other parts in an assembly can cause you and your team major headaches. Updates are unpredictable, features become corrupted, and what you thought was a real timesaver ends up costing you in terms of both time and, if you’re unlucky, lots of scrap parts.
Consider this scenario: You’re designing a bracket that connects two subassemblies to the top level assembly. Several of your colleagues are working on these subassemblies and are actively making changes. One of them deletes or moves a part and suddenly your part fails, your feature tree lights up like a Christmas tree and you have no idea why. Once you’ve fixed all the problems, someone else makes a change and it starts all over again.
Add mechanisms into the mix and parts change unexpectedly every time something moves, so you may as well wait for everyone to finish their work first before you start yours. This is why many companies forbid the use of in-context references and traditional CAD systems have been forced to implement system-wide options to disable this capability. This leaves you with two options:
- Add in-context references and be very careful (making sure you have a well documented PDM strategy in place); or
- Design bottom-up.
Unfortunately, neither choice is conducive to Agile Design.
How Onshape Tackles In-Context Design
One of the benefits of starting from scratch with a brand new CAD system is the opportunity to right all these wrongdoings. From the very beginning, Onshape developers focused on in-context design and our first deliverable was multi-part Part Studios. In a Part Studio, parts are designed together and driven from shared sketches and shared features, so features such as holes are always perfectly aligned. It’s in-context design at its best, especially when you know your design intent upfront.
Onshape window of Part Studio
Parts can reference other parts in the context of a higher level assembly
However, there are times when you need to design in the context of a higher level assembly, such as in the scenario discussed above. This is where Onshape’s unique database architecture truly shines. Along with the other core benefits of full-cloud CAD (real-time deployment, real-time data management, and real-time analytics and control), the database records every action and design decision you make. This is leveraged to your full advantage when editing a part in the context of an assembly.
How does it work? When you right-click a part in an assembly and select “edit in-context,” a snapshot of the assembly (a “Context”) is created at that moment and stored in the database forever. The part’s Part Studio is opened and all the other parts that were visible in the assembly are shown ghosted. You can then make as many references as you’d like to any of the parts from the assembly – always safe in the knowledge that those references will never be lost or broken, so your part will never fail.
It doesn’t matter if the assembly is modified by your colleagues. Your part will always remember the state of the assembly when the Context was created. If you need your part to update to reflect recent changes, you can do that, too. But you are always in control of what should update and when.
Onshape shown on tablet
Designs that require multiple part positions can be easily captured
This unique approach ensures that your parts always update in a predictable manner and motion does not affect you in any way. You can capture multiple Assembly Contexts and use them to edit single or multiple parts. You can also edit a part in the context of multiple assemblies so that the part can be reused many times.
Onshape has taken the lead on top-down design, for these reasons and more:
- Multi-part modeling
- Layout sketches in assemblies
- Multiple assembly context editing
- Unlimited restore (undo/redo)
- Branching and merging
- True collaboration and simultaneous multi-user editing of parts and assemblies
Watch the video below to see in-context design in action. If you are an avid follower of the Onshape blog, you may have seen this video before, so my apologies for that. But if you want to see the full power of in-context design, it’s worth watching again. Or better still, try it out for yourself!