What's new
By:

How to build stable assemblies

E

EPowIPi

Senior Member
Is there a tutorial somewhere with suggestions how to build stable assemblies in Alibre?
My current approach is to just click on edges or faces of parts and define constraints between those. But pretty much any change to one of the participating parts leads to pretty much all constraints getting invalid - even when the particular edge or face wasn't changed. (Perhaps all the indices for edges and faces change when a new one is added similar to previous FreeCAD versions?)
I can repair this by deleting all red constraints and recreating them, but this gets tedious.
I guess my approach is asking for trouble and there is a better one?
 
The key is to use Reference Geometry as much as possible. You can turn on and off a part's and subassembly's reference geometry via a RMB click and selecting from the pop up menu.
 
So I would define the constraints not between the edges and faces of the parts but between their reference geometries?
So when I want two parts to stick together at a particular face I would create construction planes relative to the reference planes of the parts so that they become coincident with the faces that should touch and then define the assembly constraints between those?
That can be a little tricky for some non-trivially oriented faces. But ok, should be doable. Reminds me on the "do never create sketches on faces" rule of FreeCAD. I hoped the professional CADs would be more forgiving there, but apparently there is no way around this. Will try to make construction planes then for everything.
Thanks!
 
Reference geometry can be used when it makes sense to do so. But you can use part faces and edges. Just be aware of how the parts will interact in the assembly, especially if there are going to be modifications to the parts.

Some will suggest that there should be a plane created for every sketch in a part's design. While that certainly could be a preferred design methodology some software's training will emphasize sketch-on-face as the preferred design method (I'm talking to you SolidWorks). That method has seemingly become the popular and maybe the preferred design methodology of most CAD programs. With a plane for every sketch there will almost always be reference geometry available for assembly constraints. Note that the planes are at the sketch location of the model so may not be accessible for a face of an extrusion, unless one creates a plane on the face of the extrusion when it's done.

My view is to use the method that makes sense and works for you. For years while working with SolidWorks I always used the sketch-on-face method and rarely had issues constraining to faces and edges and even the part's reference geometry. And I've had the same experience with Alibre.
 
I use both, constraining to reference geometry and constraining to faces etc.
One thing that may help to reduce problems with using faces etc. is to remember that if you change things in the part without deleting anything it will continue to use the original identifiers.
If you delete something and draw anew (even exactly the same thing) new identifiers are assigned and the constraint will go red.
 
A lot of it depends on the type of user you are: professional or hobbyist and the type of environment you work in. I am just a hobbyist, my assemblies generally are under maybe a couple of dozen parts. And for me I prefer to keep it as simple as possible. So I rarely use constraints, I just place the parts where I need them. Very rarely does this cause me any problems.
 
Using sub-assemblies can help a lot as the size/complexity increases. Only make flexible those sub-assemblies where movement withing them is needed at the top level. This reduces the work for the constraint manager, and reduces chances of conflicts.
 
DavidJ said:
Using sub-assemblies can help a lot as the size/complexity increases.
Click to expand...
I agree with David on this one and have even gone to multiple levels of sub assemblies where a specific assembly is used in may places in one design. That way there is only one place to go to correct issues. This has everything to do with design intent and can go the wrong way with complexity if not well planned.
 
I am a sometime user of Alibre Design Pro, and my understanding of how things in an assembly work is apparantly wrong. For example, when I add a constraint between an existing anchored part and a new part, say to make the faces adjoin, then slide the new part along the joined faces into its final position, the anchored part moves as well. I don't get this. If the first part is anchored, why does it move? Seems to this old Navy guy that Alibre is dragging its anchor, which is never a good idea if you want the ship to stay in one place. Is there another method to insure that once a part is positioned and "anchored" it will stay fixed regardless of what I do with other parts? Perhaps Alibre has a different working definition of "anchored" than my real world experience with the term.
 
Anchored parts stay anchored for me. Just to be sure we are talking about the same thing, when a part is anchored in an assembly it has a little anchor symbol on it in the design tree.
 
Yep, Albie, the anchor symbol is there in the properties of an anchored part, yet still it moves when another part is constrained to it then moved. Very strange, and very annoying. It could be that I have messed up something in the file setup/options unintentionally, and that's why I need some help from more experienced users.
 
Send an example to support. Either you are not doing quite what you think you are, there is a problem with your installation, or there is a bug.

If it's a bug, it must be in vary particular circumstances, as I've never heard any report of anchor not doing so.
 
Thanks everybody for the hints again!
Edit: Nooooo! It doesn't work as expected and still breaks - was wishful thinking...
What I tried was to create "joints" by introducing crossing reference lines on both parts that should be connected. So one just have to create coincident constraints in the assembly between these lines to connect the parts in the expected way (for fixed connections).
My hope was that one can get rid of part changes that look fine on the part side breaking assemblies - which only becomes apparent when opening that assembly. On first sight it looked as if the assembly constraint would reference the reference lines by name - so I could reconstruct the part, delete the reference lines and recreate them and the assembly would still work as long as there are two reference lines with the same names as before in the part.
Unfortunately Alibre is apparently not caring about the name and again using internal identifiers that the user cannot change. So if I delete a reference line recreate it and name it like the previous one was named then all assembly constraints in any assemblies referencing this reference line are broken.

@DavidJ This is a very major drawback as it makes it very hard to create stable assemblies. Imho it is very important that local changes should if somehow possible only have local impact. So if I change a part and the part shows no error then it would be crucial that assemblies using that part should also show no error as long as the part stays "compatible": There has to be a way to define an "interface" that a part can expose that can be used in assemblies. And the user has to be able to recreate a part in a way that this interface stays compatible when altering the part - or even creating a completely new drop-in replacement from scratch. Currently it doesn't seem to be possible to create such a drop in replacement as the internal symbols that seem to be hardwired in the assembly constraints cannot be recreated. So the only chance to fix this is to redo all the constraints. In all assemblies where that part occurs. This is imho really severe, PLEASE consider to change this!
 
Last edited:
The secret is to be methodical.
Put your first component into a new assembly, align it with the origin and anchor it. If it needs reorienting because it is facing the wrong way or whatever, unanchor it and constrain it with whatever planes/axes/faces you deem necessary (it doesn't really matter) to get it the right way round. Then anchor it - you'll see that the three constraints you've just made have just turned red, as the anchor is over constraining the part, so delete these constraints, the first component is anchored.

As you add other parts to the assembly, constanly keep an eye out for constraints turning red - if they do, it means the constraint you have just made conflicts with one already made. Then figure out why, correct it. Things should become clearer & you'll get to grips with the concept of constraints. Sometimes adding one that causes a conflict will throw up a stack of errors so it helps to be methodical & keep it simple!
 
The idea of crossing reference lines sounds over complex.

Instead of deleting and recreating, reference geometry - leave it in place and if needed edit the definition. That way it should still be recognised by the assembly.

Also for the basic design of a part, edit features/sketches where possible rather than deleting and recreating.

If you make changes to the topology of the design, of course it's possible that assembly constraints will need to be adjusted to compensate.
 
@Markaj the described problems start to arise when changing parts after they are already part of an/several assembly/ies. Initially all constraints are fine, they start to break after part modifications.

@DavidJ: Sometimes creating the reference geometry just based from the base axis/planes means quite some work. E.g. In my case I have walls that are not parallel to any construction axis, they are the resut of a loft between differently sized sketches. And the parts are supposed to connect on these faces. Of course transforming reference planes/axis/points to shape a connector there just from base references is possible with multiple transformations, but one always has to wrap the head around finding the right transormation matrices.
So if I could just create two reference lines on that face (or optimally a "reference joint", thus a 6dof reference that could be constrained with a single constraint) that has a name, then even if a major redesign of that part is necessary, I could just attach these reference lines (or this joint) to the resulting new face. Or even create new reference lines with the same name, if referencing would work with user definable names, not untouchable symbols.
The connection between the face and the references breaking is something I would see locally when editing the part, so it would be ok(isher). But all assembly constraints breaking once the originally referenced object is deleted without any chance to recreate a substitute and without notice is very unstable. If referencing by name/interface/etc. is not possible for whatever reason then at least the goal should still be to ensure a consistent design - by first informing the user that the deletion candidate is referenced elsewhere. And then to either a) delete the reference and all constraints that reference it. b) cancel the deletion. Currently there is no chance to know whether any geometry (reference or not) is still referenced anywhere and any change can potentially break something in a place that one might not detect for a long time. This might work for small things that are mostly built in one iteration, but is just asking for trouble for bigger projects that need multiple adjustments beyond mere reparameterization.
 
If it's going to fail anyway, just use faces. As long as the topology isn't altered, constraints will still work.

I wonder what you are doing to suffer such problems, that are not commonly reported.
 
I guess it is partially iterating on ideas for prototypes vs creating the cad model of something that is technically fully defined and just needs to be modelled for production.
In the latter case there isn't much need for changing parts (or anything else) much, one step is following on the other.
I initially started with code cad - a very high degree of parameterization / generative aspects. Software developers have found a lot of patterns to limit the impact of changes, because there change is the norm and systems usually become so big that decoupling and localizing error probabilities, having stable interfaces is the only chance to get anything ever working.
Perhaps it would be faster to rather make 5 low-parametric variants from scratch than having a design that is parameterizable enough to cover all 5 variants in one and is maintainable enough to be extensible for 10 further variants that come up in the process? (In the end a part geometry is essentially also yet another thing that might need to be changed and thus a "parameter", not only the variables.). That said. even though I experiment with CAD for a longer time now already I am sure that there is much I could still learn from more experienced cad engineers.
In the current state it is just puzzling for me that Alibre (and other programs...) COULD improve support for design stability in many ways, in some cases with few measures - and I am just surprised that apparently nobody (but me?) cares?
 
Last edited:
That said, in the current case it is apparently important that THIS reference geometry (that is used in the constraint) is never deleted. So what I can do is to reattach it to new faces if the need should arise. Then it should still work.
 
You must log in or register to reply here.
Back
Top