8 Replies Latest reply on May 9, 2014 7:16 PM by Jamil Snead

    Bottom-Up / Top-Down hybrid

    Richard K.

      Short question:


      Can I insert multiple copies of a part, perhaps across several unrelated assemblies, but dimension them differently or use different "master" skeleton sketches to drive them?  Can all the different instances / assemblies share a single part file?


      Long version:


      I'm new to assemblies and looking for some advice on design methodology.  I'm trying to create a set of generic, reusable components that can be adjusted when placed in another part or assembly.


      Here's how I'm picturing it should work in my head:


      Let's say I design a "parametric" cabinet part where the width, height and depth are adjustable.  Accomplishing this seems straightforward; I can a) simply leave those three dimensions undefined in my sketch[es], b) mark them as "driven", or c) attach them to global variables.  The sketches are set up such that I can drag around the undefined entities (or play with the variables) and the part responds intelligently - i.e. as the overall cabinet width grows, the thickness of its sides remains constant.


      Next I want to drop the part into an assembly (or another part), and do one or more of the following:


      1) Dimension the sides of the cabinet as a whole

      2) Set up mates to define its dimensions (e.g. mate the sides of the cabinet to two fixed, adjacent walls)

      3) Define relations between the part and entities in a "skeleton sketch" in my assembly (i.e. "top-down" approach where a master sketch drives the placed part)

      4) Fuse variables in the part to variables / equations in the assembly (a more mathematical top-down approach).


      After any of these operations, the placed "instance" of the part becomes fully defined and should react accordingly.  e.g. In #2 above, the width of the cabinet would grow to meet the two walls.  (I dream of being able to define "handles" or external attachment points in the part, and expose them for this purpose; sort of a geometric kin to using global variables as parameters).


      I'd like to place several of these cabinets, of varying sizes, perhaps across multiple unrelated assemblies.  The sizes are not known beforehand and they are infinitely variable, which rules out using configurations to define a set of standard sizes. (And in any case I'd rather leave that feature for genuine differences in configuration, e.g. butt vs. mitered joinery, and avoid needlessly ballooning the number of permutations).


      I seem to be able to do at least some of #1-4 after placing the part in an assembly, but as soon as I change the size of one instance (e.g. by editing its sketch in the context of the assembly), it changes for all of them.  I haven't figured out how to get this to work without making several copies of the original part file, which gets ugly.


      Later on I may want to tweak the internals of the part - say, fillet the edges - and I want the change to be reflected in all the assemblies that use it (without having to tweak a ton of different files).


      I understand this entails a need to be careful how I "bind" part instances to other items.  e.g. Let's say in the assembly I defined a mate or relation between something (e.g. a wall) and the edge of the cabinet.  I believe it would now break down after my tweak, since that edge has been absorbed into the fillet.  To work around this, I'm considering putting a skeleton sketch in the part itself, and a corresponding skeleton sketch in the assembly.  The skeleton inside my part deals with the stuff the part designer wants to expose externally (i.e. entities which can be adjusted, exposed attachment points - essentially this sketch creates the "handles" I was dreaming about earlier) and the one in the assembly is the "puppetmaster" that actually drives a placed instance of the part.  (And when I say "sketch" I guess I'm really talking about a pair of sketches or more, to handle the X, Y and Z dimensions, unless I go down the 3D sketch path).


      My questions are:

      i. Does the general approach I've outlined make sense, and can it be accomplished?  Or is it unorthodox and should I do this differently?

      ii. Can / should I do this through geometry (i.e. a & b above), or by somehow fusing global variables between files (c above).  Is the latter even possible? (e.g. maybe using Excel files as glue...)

      iii. Is there a way to avoid creating a new part file for each instance, while still allowing those instances to differ in size?

      iv. Do I need to read more about the "layout" or "block" features?

      v. Are there best practices out there to help me avoid any other common pitfalls as the complexity of my assemblies grows?

      vi. Do other popular modeling programs deal with this notably different from Solidworks?

      vii. When I place a part, it seems everything is fair game for attachments, mates, etc.  Is there any way to suppress the internal sketches from being available for this?  (e.g. hide the part's internal sketches and just show its skeleton sketch?)

      viii. When designing a part in the manner described by (a) or (b) above, Solidworks always tells me the sketch is under defined.  Is there a way to mark some dimensions as "parameters" (or "intentionally missing") to ignore them for this purpose and regain the useful indicator of whether my sketch is "defined enough"?  Right now I'm using placeholder dimensions which I change to Driven before saving the file.


      It's worth nothing that while I've used overall size as the parameters in my example (width/height/depth), in practice the things I want to set up as parametric may not correspond to the "bounding box" of my part.  I also intend to propogate things like cut lists, sensors, etc. from my part into the parent assemblies.


      Any help you can offer to point me in the right direction is much appreciated!

        • Re: Bottom-Up / Top-Down hybrid
          Denny Peter

          For Short question


          Yes you can, make configuration to change the dimension, let me read you long version to help

          • Re: Bottom-Up / Top-Down hybrid
            Glenn Schroeder

            You can have configurations or you can have seperate part files.  I'm pretty sure those are your only options.


            I would recommend having one part of this type for each project, with configurations to deal with the different sizes needed for that project.  You could have a basic part saved in your parts library, that you would copy and paste into the folder for each project, then re-name specific to the project and edit as needed.

            • Re: Bottom-Up / Top-Down hybrid
              Jamil Snead

              As Deepak suggested in the thread below, look into configuration publisher. I know you can't predict all configurations that you will ever need to use, but you can create each new one as needed.

              inserting part with unknown configuration to assembly


              Glenn's suggestion about having a part file for each assembly is good, but you would miss out on the opportunity to have one change propagate through all instances of that same type of part in all assemblies. Depending on the volume of different parts you need to make you might be able to just have all sizes be a unique config in the part. I think you'd be ok even to have hundreds of configurations in a single part.

                • Re: Bottom-Up / Top-Down hybrid
                  Patrick O'Hern

                  I have a file with over 3000 configs.  It works great, but it's a large file and it tends to slow down my assembies.  I plan on breaking it up into some smaller files in the future...

                  • Re: Bottom-Up / Top-Down hybrid
                    Richard K.

                    Hi everyone, I appreciate the responses.  I'm disappointed there isn't a more elegant way to do this than configurations.  I think what I'm looking for is something like "Adjustable Parts" in Solid Edge.  I'm not the only one, e.g. https://forum.solidworks.com/message/387830


                    I played with the configurations route some more.  A critical piece of this is that I want the part size to adjust fluidly as I edit its constraining features in the assembly.  i.e. If I move the walls, I don't want to have to go back and pick/create a different configuration to update the size of the cabinet.


                    The workflow I've come up with is:


                    1) Start each part with a single, "generic" configuration where the adjustable parameters (e.g. width) are left out or marked as "driven".

                    2) Add a new configuration every time I insert the part (unless the new instance will be identical to a previous one).

                    3) Edit the part in the context of the assembly, with the new configuration active.

                    - Create relations between the sketch entities in my part and a skeleton sketch in the assembly or parent part.

                    - Be careful to mark the relations as "only for this configuration".

                    - Do not create relations between part features (e.g. edges) or sketch entities which may be lost if the part is changed.  If the part is complex, create a simple skeleton sketch within the part intended to provide a "mounting fixture" for external relations or mates.

                    4) When making seed edits to the part, check that any changes or new features propogate to the different configurations correctly.


                    It seems like a lot of cognitive overhead.  And I'm wary of having relation logic to the assembly embedded within the part file - my instinct says it violates a fundamental principle of encapsulation.  (I guess I need to think of the different configurations as belonging to their respective assemblies).



                      • Re: Bottom-Up / Top-Down hybrid
                        Tim Glavin



                        Your workflow nearly describes the way Genus Designer (a SolidWorks add-in and partner product) works.


                        What you call "generic part configurations", we call "classes" or "templates" and identify them as "assets" where the managed parameters are identified in advance. Pre-built "instances" are looked up and referenced from a common library.


                        Designer's assets can be flagged to create either new files or new configurations in a single file when a new parameterization or feature set has been identified.


                        Designer has its own engineering model, driven top-down. Class/Sub-class, Parent/Child and Orients/Oriented-by relationships exist in the engineering model. The SolidWorks model is created bottom-up (automatically) just the way you would do it interactively, perhaps a tad faster (ok, a LOT faster). Orientations relate reference geometry (not ephemeral vertices, edges or faces).


                        It is not master-model based and uses no design tables. It is generative (you can add features to parts and parts to assemblies). It doesn't suffer the complexity problems of master-modeling.


                        Design writes a new SolidWorks model to a working directory and assembly-to-part references are repaired. Only references to library parts are external to the working directory. We don't use In-context references.


                        Our class and instance files don't violate encapsulation, so are re-usable.


                        There is a lot of book-keeping done to keep this all straight, especially since the language is declarative. The good news is, you don't have to manage the bookkeeping.


                        Richard, you have designed a pretty good workflow. We implemented it (with a few modifications). It's in version 9.




                        - Tim

                        • Re: Bottom-Up / Top-Down hybrid
                          Jamil Snead

                          That sounds like a good method. I couldn't think of a way to have the configuration of the part update automatically with your assembly, but you figured out a creative way. I didn't know you could have different configurations of a part driven by in-context relations from different assemblies.


                          A couple things come to mind after reading that workflow:


                          1. Having a bunch of configurations of a part isn't that bad in terms of taking up memory, but to have each config of that part driven by a different assembly might bog down the system. If you do end up implementing that method I'd be interested to hear if you notice any speed issues.


                          2. When a particular assembly is finalized and the dimensions are not likely to change, maybe you'd want to break the relations and just hard-dimension the part. Then you could rename the configuration something descriptive to indicate the dimensions. That way you could identify if you have already made an identical configuration. Also that way you wouldn't be keeping lots of external references in the part. The only tricky thing if you do that is if later you end up needing to modify one assembly, you'd need to either figure out if that part config is used anywhere else, or just always create a new configuration. To be safe you could just create a new part config if you ever need to modify it after the descriptive name has been created.