Assembly Modeling with ANSYS

In my previous article, I wrote about how you get what you pay for with your analysis package.  Well, buckle up for some more…but this time we’ll just focus on handling assemblies in your structural/thermal simulations.  If all you’re working on are single components, count yourself lucky.  Almost every simulation deals with one part interacting with another.  You can simplify your boundary conditions a bit to make it equivalent, but if you have significant bearing stresses, misalignments, etc…you need to include the supporting parts.  Better hope your analysis package can handle contact…

Image result for get what you pay for

First off, contact isn’t just for structural simulations.  Contact allows you to pass loads across difference meshes, meaning you don’t need to create a conformal mesh between two parts in order to simulate something.  Here’s a quick listing on the degrees of freedom supported in ANSYS (don’t worry…you don’t need to know how to set these options as ANSYS does it for you when you’re in Workbench):


You can use contact for structural, thermal, electrical, porous domain, diffusion, or any combination of those.  The rest of this article is going to focus on the structural side of things, but realize that the same concepts apply to essentially any analysis you can do within ANSYS Mechanical..

First, it’s incredibly easy to create contact in your assembly.  Mechanical automatically looks for surfaces within a certain distance from one another and builds contact.  You can further customize the automated process by defining your own connection groups, as I previous wrote about.  These connection groups can create contact between faces, edges, solids bodies, shell bodies, and line bodies.


Second, not only can you create contact to transfer loads across different parts, but you can also automatically create joints to simulate linkages or ‘linearize’ complicated contacts (e.g. cylindrical-to-cylindrical contact for pin joints).  With these joints you can also specify stops and locks to simulate other components not explicitly modeled.  If you want to really model a threaded connection you can specify the pitch diameter and actually ‘turn’ your screw to properly develop the shear stress under the bolt head for a bolted joint simulation without actually needing to model the physical threads (this can also be done using contact geometry corrections)

image Look ma, no threads (modeled)!


If you’re *just* defining contact between two surfaces, there’s a lot you simulate.  The default behavior is to bond the surfaces together, essentially weld them closed to transmit tensile and compressive loads.  You also have the ability to let the surfaces move relative to each other by defining frictionless, frictional, rough (infinite coefficient of friction), or no-separation (surfaces don’t transmit shear load but will not separate).


Some other ‘fancy’ things you can do with contact is simulate delamination by specifying adhesive properties (type I, II, or III modes of failure).  You can add a wear model to capture surface degradation due to normal stress and tangential velocity of your moving surfaces.  You can simulate a critical bonding temperature by specifying at what temperature your contacts ‘stick’ together instead of slide.  You can specify a ‘wetted’ contact region and see if the applied fluid pressure (not actually solving a CFD simulation, just applying a pressure to open areas of the contact interface) causes your seal to open up.


Now, it’s one thing to be able to simulate all of these behaviors.  The reason you’re running a finite element simulation is you need to make some kind of engineering judgement.  You need to know how the force/heat/etc transfers through your assembly.  Within Mechanical you can easily look at the force for each contact pair by dragging/dropping the connection object (contact or joint) into the solution.  This will automatically create a reaction probe to tell you the forces/moments going through that interface.  You can create detailed contour plots of the contact status, pressure, sliding distance, gap, or penetration (depending on formulation used).



Again, you can generate all of that information for contact between surface-to-surface, surface-to-edge, or edge-to-edge.  This allows you to use solids, shells, beams, or any combination you want, for any physics you want, to simulate essentially any real-world application.  No need to buy additional modules, pay for special solvers, fight through meshing issues by trying to ‘fake’ an assembly through a conformal mesh.  Just import the geometry, simplify as necessary (SpaceClaim is pretty awesome if you haven’t heard), and simulate it.)

For a more detailed, step-by-step look at the process, check out the following video!

Advanced ANSYS Functionality

Just like any other marketplace, there are a lot of options in simulation software.  There are custom niche-codes for casting simulations to completely general purpose linear algebra solvers that allow you to write your own shape functions.  Just like with most things in life, you truly get what you pay for.

Image result for get what you pay for


For basic structural and thermal simulations pretty much any FE-package should suffice.  The difference there will be in how easy it is to pre/post process the work and the support you receive from the vendor.  How complicated is the geometry to mesh, how long does it take to solve, if you can utilize multiple cores how well does it scale, how easy is it to get reactions at interfaces/constraints…and so on.  I could make this an article about all the productivity enhancements available within ANSYS, but instead I’ll talk about some of the more advanced functionalities that differentiate ANSYS from other software out there.

  • Radiation

You can typically ignore radiation if there isn’t a big temperature gradient between surfaces (or ambient) and just model your system as conduction/convection cooled.  Once that delta is large enough to require radiation to be modeled there are several degrees of numerical difficulty that need to be handled by the solver.

First, radiating to ambient is fairly basic but the heat transfer is now a function of T^4.  The solver can also be sensitive to initial conditions since large DT results in a large heat transfer, which can then result in a large change in temperature from iteration to iteration.  It’s helpful to be able to run the model transiently or as a quasi-static to allow the solver to allow some flexibility.

Next, once you introduce surface to surface radiation you now have to calculate view factors prior to starting the thermal solution. If you have multiple enclosures (surfaces that can’t see each other, or enclosed regions) hopefully there are some processes to simplify the view factor calculations (not wasting time calculating a ‘0’ for elements that can’t radiate to each other).  The view factors can sometimes be sensitive to the mesh density, so being able to scale/modify those view factors can be extremely beneficial.

Lastly you run into the emissivity side of things.  Is the emissivity factor a function of temperature?  A function of wavelength?  Do you need to account for absorption in the radiation domain?

Luckily ANSYS does all of this.  ANSYS Mechanical allows you to easily define radiation to ambient or surface-to-surface.  If you’re using symmetry in your model the full radiating surface will be captured automatically.  You can define as many enclosures as possible, each with different emissivity factors (or emissivity vs Temperature).  There are more advanced features that can help with calculating view factors (simplify the radiating surface representation, use more ray traces, etc) and there is functionality to save the calculated view factors for later simulations.  ANSYS fluid products (CFX and Fluent) can also account for radiation and have the ability to capture frequency-based emissivity and participating media.


Automatic expansion of radiating surfaces across symmetry planes


Different enclosures to simplify view factor calculations

Long story short…you don’t have to know what the Stefan-Boltzman constant is if you want to include radiation in your model (bonus points if you do).  You don’t have to mess with a lot of settings to get your model to run.  Just insert radiation, select the surface, and run.  Additional options and technical support is there if necessary.

  • Multiple/Multi-physics

I’d expect that any structural/thermal/fluids/magnetics code should be able to solve the basic fundamental equations for the environment it simulates.  However, what happens when you need to combine physics, like a MEMs device.  Or maybe you want to take some guess-work/assumptions out of how one physics loads another, like what the actual pressure load is from a CFD simulation on a structural model.  Or maybe you want to capture the acoustic behavior of an electric motor, accounting for structural prestress/loads such as Joule heating and magnetic forces.


ANSYS allows you to couple multiple physics together, either using a single model or through data mapping between different meshes.  Many of the data mapping routines allow for bi-directional data passing so the results can converge.  So you can run an magnetic simulation on the holding force between a magnet and a plate, then capture the deflected shape due to an external load, and pass that deformed shape back to the magnetic simulation to capture the updated force (and repeat until converged).


If you have vendor-supplied data, or are using another tool to calculate some other results you can read in point cloud data and apply it to your model with minimal effort.


To make another long story short…you can remove assumptions and uncertainty by using ANSYS functionality.

  • Advanced Material Models


Any simulation tool should be able to handle simple linear material models.  But there are many different flavors of ‘nonlinear’ simulation.  Does the stiffness change due to deflection/motion (like a fishing rod)?  Are you working with ductile metals that experience plastic deformation?  Does the stiffness change due to parts coming into/out-of contact?  Are surfaces connected through some adhesive property that debonds under high loads?  Are you working with elastomers that utilize some polynomial form hyper-elasic formulation?  Are you working with shape memory alloys?  Are you trying to simulate porous media through some geomechanical model?  Are you trying to simulate a stochastic material variation failure in an impact/explosive simulation?


Large deflection stiffness calculations, plasticity, and contact status changes are easy in ANSYS.  Debonding has been available since ANSYS 11 (reminder, we’re at release 18.0 now).  ANSYS recently integrated some more advanced geomechanical models for dam/reservoir/etc simulations.  The explicit solver allows you to introduce stochastic variation in material strengths for impact/explosive simulations.


ANSYS also has all the major flavors of hyper-elastic material models.  You can choose from basic Neo-Hookean, Arruda-Boyce, Gent, all the way through multiple variations of Mooney-Rivlin, Yeoh, Ogden, and more.  In addition to having these material models available (and the curve fitting routines to properly extract the constants from test data) ANSYS also has the ability to dynamically remesh a model.  Most of the time when you’re analyzing the behavior of a hyperelastic part there is a lot of deformation, and what starts out as a well-shaped mesh can quickly turn into a bad mesh.  Using adaptive meshing, you can have the solve automatically pause the solution, remesh the deformed shape, map the previous stress state onto the new nodes/elements, and continue with the solution.  I should note that this nonlinear adaptive remesh is NOT just limited to hyperelastic simulations…it is just extremely helpful in these instances.

The ending of this story is pretty much the same as others.  If you have a complicated material response that you’re trying to capture you can model it in ANSYS.  If you already know how to characterize your material, just find the material model and enter the constants.  We’ve worked with several customers in getting their material tested and properly characterized.  So while most structural codes can do basic linear-elastic, and maybe some plastic…very few can capture all the material responses that ANSYS can.

  • MEMs/Piezo/Etc

I know I’ve already discussed multiple physics and advanced materials, but once you start making parts smaller you start to get coupling between physics that may not work well for vector-based coupling (passing load vectors/deformations from one mesh to another).  Luckily ANSYS has a range of multi-physics elements that can solve use either weak or strong coupling to solve a host of piezo or MEM-related problems (static, transient, modal, harmonic).  Some codes allow for this kind of coupling but either require you to write your own governing equations or pay for a bunch of modules to access.

If you have the ANSYS Enterprise-level license you can download a free extension that exposes all of these properties in the Mechanical GUI.  No scripting, no compiling, just straight-up menu clicks.


Using this extension you can define the full complex piezoelectric matrix, couple it with an anisotropic elasticity matrix, and use frequency dependent losses to capture the actual response of your structure.  Or if you want you can use simplified material definitions to get the best approximation possible (especially if you’re lacking a full material definition from your supplier).


Long story short…there are a lot of simulation products out there.  Pretty much any of them should be able to handle the basics (single part, structural/thermal, etc).  What differentiates the tools is in how easy it helps you implement more real-world conditions/physics into your analysis.  Software can be expensive, and it’s important that you don’t paint yourself into a corner by using a single point-solution or low-end tool.

Connection Groups and Your Sanity in ANSYS Mechanical

You kids don’t know how good you have it with automatic contact creation in Mechanical.  Back in my day, I’d have to use the contact wizard in MAPDL or show off my mastery of the ESURF command to define contacts between parts.  Sure, there were some macros somewhere on the interwebs that would go through and loop for surfaces within a particular offset, but for the sake of this stereotypical “old-tyme” rant, I didn’t use them (I actually didn’t, I was just TOO good at using ESURF to need anyone else’s help).

Image result for old tyme

Hey, it gets me from point A to B

In Mechanical contact is automatically generated based on a set of rules contained in the ‘Connection Group’ object:


It might look a little over-whelming, but really the only thing you’ll need to play around with is the ‘Tolerance Type’.  This can either ‘Slider’ or ‘Value’ (or use sheet thickness if you’re working with shells).  What this controls is the face offset value for which Mechanical will automatically build contact.  So in the picture shown above faces that are 5.9939E-3in apart will automatically have contact created.  You can play around with the slider value to change what the tolerance

image image image

As you can see, the smaller the tolerance slider the larger the ‘acceptable’ gap becomes.  If you change the Tolerance Type to be ‘Value’ then you can just directly type in a number.

Typically the default values do a pretty good job automatically defining contact.  However, what happens if you have a large assembly with a lot of thin parts?  Then what you run into is non-sensical contact between parts that don’t actually touch (full disclosure, I actually had to modify the contact settings to have the auto-generated contact do something like this…but I have seen this in other assemblies with very thin/slender parts stacked on top of each other):


In the image above, we see that contact has been defined between the bolt head and a plate when there is clearly a washer present.  So we can fix this by going in and specifying a value of 0, meaning that only surfaces that are touching will have contact defined.  But now let’s say that some parts of your assembly aren’t touching (maybe it’s bad CAD, maybe it’s a welded assembly, maybe you suppressed parts that weren’t important).


The brute force way to handle this would be to set the auto-detection value to be 0 and then go back and manually define the missing contacts using the options shown in the image above.  Or, what we could do is modify the auto-contact to be broken up into groups and apply appropriate rules as necessary.  The other benefit to this is if you’re working in large assemblies, you can retain your sanity by having contact generated region by region.   In the words of the original FE-guru, Honest Abe, it’s easier to manage things when they’re logically broken up into chunks.


Said No One Ever

Sorry…that was bad.  I figured in the new alt-fact world with falsely-attributed quotes to historical leaders, I might as well make something up for the oft-overlooked FE-crowd.

So, how do you go about implementing this?  Easy, first just delete the default connection group (right-mouse-click on it and select delete).  Next, just select a group of bodies and click the ‘Connection Group’ button:

image image image

In the image series above, I selected all the bolts and washers, clicked the connection group, and now I have created a connection group that will only automatically generate contact between the bolts and washers.  I don’t have to worry about contact being generated between the bolt and plate.  Rinse, lather, and repeat the process until you’ve created all the groups you want:


ALL the Connection Groups!

Now that you have all these connection groups, you can fine-tune the auto-detection rules to meet the ‘needs’ of those individual body groups.  Just zooming in on one of the groups:


By default, when I generate contact for this group I’ll get two contact pairs:

image image

While this may work, let’s say I don’t want a single contact pair for the two dome-like structures, but 2.  That way I can just change the behavior on the outer ‘ring’ to be frictionless and force the top to be bonded:


I modified the auto-detection tolerance to be a user-defined distance (note that when you type in a number and move your mouse over into the graphics window you will see a bulls-eye that indicates the search radius you just defined).  Next, I told the auto-detection not to group any auto-detected contacts together.  The result is I now get 3 contact pairs defined:

image image image

Now I can just modify the auto-generated contacts to have the middle-picture shown in the series above to be frictionless.  I could certainly just manually define the contact regions, but if you have an assembly of dozens/hundreds of parts it’s significantly easier to have Mechanical build up all the contact regions and then you just have to modify individual contact pairs to have the type/behavior/etc you want (bonded, frictionless, symmetric, asymmetric, custom pinball radius, etc).  This is also useful if you have bodies that need to be connected via face-to-edge or edge-to-edge contact (then you can set the appropriate priority as to which, if any of those types should be preserved over others).

So the plus side to doing all of this is that after any kind of geometry update you shouldn’t have much, if any, contact ‘repair’ to do.  All the bodies/rules have already been fine tuned to automatically build what you want/need.  You also know where to look to modify contacts (although using the ‘go to’ functionality makes that pretty easy as well).  That way you can define all these connection groups, leave everything as bonded and do a preliminary solve to ensure things look ‘okay’.  Then go back and start introducing some more reality into the simulation by allowing certain regions to move relative to each other.

The downside to doing your contacts this way is you risk missing an interface because you’re now defining the load path.  To deal with that you can just insert a dummy-modal environment into your project, solve, and check that you don’t have any 0-Hz modes.

Donny Don’t – Thin Sweep Meshing

It’s not a series of articles until there’s at least 3, so here’s the second article in my series of ‘what not to do’ in ANSYS…

Just in case you’re not familiar with thin sweep meshing, here’s an older article that goes over the basics.  Long story short, the thing sweep mesher allows you to use multiple source faces to generate a hex mesh.  It does this by essentially ‘destroying’ the backside topology.  Here’s a dummy board with imprints on the top and bottom surface:


If I use the automatic thin sweep mesher, I let the mesher pick which topology to use as the source mesh, and which topology to ‘destroy’.  A picture might make this easier to understand…


As you can see, the bottom (right picture) topology now lines up with the mesh, but when I look at the top (left picture) the topology does not line up with the mesh.  If I want to apply boundary conditions to the top of the board (left picture), I will get some very odd behavior:


I’ve fixed three sides of the board (why 3?  because I meant to do 4 but missed one and was too lazy to go back and re-run the analysis to explain for some of future deflection plots…sorry, that’s what you get in a free publication) and then applied a pressure to all of those faces.  When I look at the results:


Only one spot on the surface has been loaded.  If you go back to the mesh-with-lines picture, you’ll see that there is only a single element face fully contained in the outline of the red lines.  That is the face that gets loaded.  Looking at the input deck, we can see that the only surface effect element (how pressure loads are applied to the underlying solid) is on the one fully-contained element face:


If I go back and change my thin sweep to use the top surface topology, things make sense:


The top left image shows the thin sweep source definition.  Top right shows the new mesh where the top topology is kept.  Bottom left shows the same boundary conditions.  Bottom right shows the deformation contour.

The same problem occurs if you have contact between the top and bottom of a thin-meshed part.  I’ll switch the model above to a modal analysis and include parts on the top and bottom, with contact regions already imprinted.


I’ll leave the thin sweeping meshing control in place and fix three sides of the board (see previous laziness disclosure).  I hit solve and nothing happens:


Ah, the dreaded empty contact message.  I’ll set the variable to run just to see what’s going on.  Pro Tip:  If you don’t want to use that variable then you would have to write out the input deck, it will stop writing once it gets to the empty contact set.  Then go back and correlate the contact pair ID with the naming convection in the Connections branch.

The model solves and I get a bunch of 0-Hz (or near-0) modes, indicating rigid body motion:


Looking at some of those modes, I can see that the components on one side of my board are not connected:


The missing contacts are on the bottom of the board, where there are three surface mounted components (makes sense…I get 18 rigid body modes, or 6 modes per body).  The first ‘correct’ mode is in the bottom right image above, where it’s a flapping motion of a top-mounted component.

So…why don’t we get any contact defined on the bottom surface?  It’s because of the thin meshing.  The faces that were used to define the contact pair were ‘destroyed’ by the meshing:


Great…so what’s the take-away from this?  Thin sweep meshing is great, but if  you need to apply loads, constraints, define contact…basically interact with ANYTHING on both sides of the part, you may want to use a different meshing technique.  You’ve got several different options…

  1. Use the tet mesher.  Hey, 2001 called and wants its model size limits back.  The HPC capabilities of ANSYS make it pretty painless to create larger models and use additional cores and GPUs (if you have a solve-capable GPU).  I used to be worried if my model size was above 200k nodes when I first started using ANSYS…now I don’t flinch until it’s over 1.5M
    Look ma, no 0-Hz modes!
  2. Use the multi-zone mesher.  With each release the mutli-zone mesher has gotten better, but for most practical applications you need to manually specify the source faces and possibly define a smaller mesh size in order to handle all the surface blocking features.
    Look pa, no 0-Hz modes!Full disclosure…the multi-zone mesher did an adequate job but didn’t exactly capture all of the details of my contact patches.  It did well enough with a body sizing and manual source definition in order to ‘mostly’ bond each component to the board.
  3. Use the hex-dominant mesher.  Wow, that was hard for me to say.  I’m a bit of a meshing snob, and the hex dominant mesher was immature when it was released way back when.  There were a few instances when it was good, but for the most part, it typically created a good surface mesh and a nightmare volume mesh.  People have been telling me to give it another shot, and for the most part…they’re right.  It’s much, much better.  However, for this model, it has a hard time because of the aspect ratio.  I get the following message when I apply a hex dominant control:

  4. The warning is right…the mesh looks decent on the surface but upon further investigation I get some skewed tets/pyramids.  If I reduce the element size I can significantly reduce the amount of poorly formed elements:image
  5. That’s going on the refrigerator door tonight!
    And…no 0-Hz modes!
  • Lastly…go back to DesignModeler or SpaceClaim and slice/dice the model and use a multi-body part.image
    3 operations, ~2 minutes of work (I was eating at the same time)

    Modify the connection group to search/sort across parts


    That’s a purdy mesh!  (Note:  most of the lower-quality elements, .5 and under, are because there are 2-elements through thickness, reducing the element size or using a single element thru-thickness would fix that right up)

    And…no 0-Hz modes.

Phew…this was a long one.  Sorry about that.  Get me talking about meshing and look what happens.  Again, the take-away from all of this should be that the thin sweeper is a great tool.  Just be aware of its limitations and you’ll be able to avoid some of these ‘odd’ behaviors (it’s not all that odd when you understand what happens behind the scenes).

Donny Don’t – Remote Objects

Nothing like a good ‘ol fashion Simpson’s reference.  I’m trying to start a new series of articles that address common mistakes and things to avoid, and what better reference than when Bart ‘joined’ the Junior Campers and found out he might get a knife out of the deal. 


For this first article, let’s talk about remote objects (force, displacement, points, joints).  First, remote objects are awesome.  Want to add a rotational DOF to your solid-object model?  Remote Displacement.  Want to apply a load and don’t want to worry about force/moment balance?  Remote Force.  Want to apply a load but also constrain a surface?  Remote Point.  Take two points and define a open/locked degrees of freedom and you have a kinematic joint.

The thing to watch out for is how you define these remote points.  ANSYS Mechanical does an amazing job at making a pretty tedious process easy (create pilot node, create constraint-type contact, specify DOFs to include, specify formulation).  In Mechanical, all you need to do is highlight some geometry, right mouse click, and insert the appropriate object (remote point, remote force, etc).  No need to keep track of real constant sets, element tshape’s…easy.  Almost too easy if you ask me.

Once you start creating multiple remote objects, you may see the following:


If you dig into the solver output file you may see this:


The complaint is that we have multiple overlapping constraint sets.  Let’s take a step back and see the model I’ve setup:


I have a cylinder, attached to a body-to-ground spring on one face, a translational joint applied on the OD, and a remote force and moment applied on the opposite end.  If I follow the instructions shown from the ANSYS Workbench message about graphically displaying FE Connections (select the ‘Solution Information’ item, click the graphics tab):


We can see that any type of constraint equation is shown in red.  The issue here is that the nodes on the OD edge on the top and bottom of my cylinder belong to multiple constraint equation sets.  On the bottom my my cylinder those nodes are being constrained to the spring end AND the cylindrical joint.  On the top the nodes on the edge are being constrained to the joint AND remote force.  When you hit solve, ANSYS needs to figure out how to resolve the conflicting constraint sets (a node cannot be a slave term for two different constraint sets).  I don’t know exactly how the solver manages this, but I like to imagine it’s like two people fighting over who gets to keep a dog…and they place the dog in-between them and call for it, and whoever the dog goes to gets to keep it. 

Now for this example, the solver is capable of handling the over-constraint because overall…the model is properly constrained.  The spring can loose some of the edge nodes and still properly connect to the cylinder.  Same goes for the other remote objects (translation joint and remote force/moment).  If we had more objects defined and more overlaps, that’s a different story.  You can introduce a pretty lengthy lag, or outright solver failure, if there are a lot of overconstraint terms in the model. 

So now the question becomes, how do I fix this.  The easiest way is to not fix this and ignore the warning.  If our part behaves properly, we get the reaction forces we’d expect, then odds are the overconstraint terms that are automatically corrected are fine.  If we actually wanted to remove that warning, we would need to make sure we scope remote objects that do not touch other remote objects.  We can do this by going into DesignModeler or SpaceClaim and imprinting the surfaces. 


In DM, I just extruded the edges with the operation set to imprint face.  In SpaceClaim you would just need to use the ‘copy edge’ option on the pull command:


Now this will modify the topology and will ensure we have a separation of nodes for all of our remote objects:


When we solve…no warning message about MPC conflicts:


And when we look at the FE connectivity, there are no nodes shared by multiple remote objects:


The last thing I’d like to point out is the application of a force and moment on a remote point:


Whenever you have two remote objects operating on the same surface (e.g. a moment and force, force and displacement, etc), you should really be using a remote point.  If I were to create two remote objects:


I now come right back to my original problem of conflicting constraints.  These two objects share the exact same nodal set but are creating two independent remote points.  If you want to do this, right-mouse-click on one of your remote objects and select ‘promote to remote point’:


Then modify the other remote objects to use that remote point.  No more conflict. 

Very last point…in R16 it will now tell you when you have ‘duplicate’ remote objects  (like the remote force + displacement shown above). 


Hope this helps! 

Named Selections + Object Generator = Awesome

Guess who’s back…back again.  Yes, just like Slim Shady, I’m back (returned to PADT and writing Focus blogs).

So run and go tell your friends that horrible pop cultural references have returned to ANSYS blog posts.  It’s been too long.

Getting back on track, the object generator debuted in R14.5 Mechanical.  You can access this feature in the toolbar (image below taken from R15):

How the pro's generate objects

What exactly does the object generator do?  Simple answer…it makes your life better.  It uses named selections and a single instance of an object (joint, spring, bolt pretension, etc) and replicates it across all entities in the named selection.  Let’s play around with this feature on the following (dummy) assembly:


Above is a t-pipe with three covers, one of them has bolt ‘bodies’ modeled.  We’ll use fixed-fixed joints to connect the two ‘bolt-less’ bodies together, and then define bolt preloads on the bolt pattern.  To get started, we need to build up the named selections. 

I’m planning on defining the fixed-fixed joint between the two cylindrical surfaces:


This is a pretty simple assembly, and I could easily just manually select them all, right-mouse-click, and generate the named selection.  In the real world, things aren’t always so easy, so we’ll get a little fancy.  First, create a named selection of the bodies that contain faces we want to joint together:


I’ve created two named selections, called ‘joint_cover’ and ‘joint_pipe’ and utilized the ‘random colors’ option to display them in different colors.  Next, I insert a named selection but set the scoping method to be ‘by worksheet’:


I’ll then use selection logic (MAPDL hipsters will recognize the logic as the xSEL commands):


Now, order is important here, as the selection logic ‘flows’ from top to bottom.  First, this named selection selects the bodies contained in the existing named selection ‘joint_cover’ (note:  this object MUST exist above the worksheet-created named selection in the tree).  At this point in time, we have two bodies selected.  Next, it converts my body selection to faces belonging to those bodies.  Finally, it filters out any face that has a radius less than .05m (units are set by the ‘units’ drop-down menu, values entered in worksheet scale when units are changed).  Hit ‘generate’ and you get the following:


You may need to switch to the ‘graphics’ tab (circled in red in the above image).  This is great, we now have all of our faces highlighted.  Next, we need to reproduce this behavior on the pipe.  Rather than redo all of this work, just right-mouse-click on our new named selection and select ‘duplicate’. 

image image

Select the duplicated named selection, and edit the first line to use a different named selection.  Hit generate:


Perfect.  We can go back and add/remove bodies to the existing named selections and re-generate the named selections to have it automatically re-create these named selections. 

Next, we’ll create the original ‘joint’ we want to re-create across the two flanges. 


After making the joint, make note of which part is the ‘reference’ and ‘mobile’.  For the image above, the cover is the ‘reference’ while the pipe is the ‘mobile’.  Highlight this joint and select the object generator:


If we use the object generator on a joint, it will ask us to define the named selections that contain the reference and mobile faces.  From above, we know that the cover faces are contained in the ‘cover_faces’ named selection.  We then duplicated that and swapped the body selection, meaning the faces for the pipe are contained in ‘cover_faces 2’ (I’m lazy and didn’t rename it…sorry).  Next, we define the minimum distance between centroids.  This acts as a filter for re-creating each joint.  What happens when we hit ‘generate’ is it looks at the distance between the centroids of each face in the two named selections.  If it finds ‘matching’ faces within that distance it creates the joint. 


In the image above, if I use a distance equal to the red line, I will get incorrect joints defined.  I’ll get the following (a=cover, b=pipe): 1a-1b, 1a-2b, 2a-2b, 2a-1b…

What I need to do is limit the distance to the blue line, which is big enough to find the correct pairs but filter out the wrong ones.  To figure out a proper distance, you can use the ‘selection information’ window to figure out the centroid information:


Once you’re set, hit ‘generate’:


What a time to be alive!  It’s always a good idea to go through joint-by-joint to make sure everything is correct…or you can always just count the number of joints created and confirm that the number is correct (I have 15 total faces in the cover_faces named selection…so I should have 15 joints…and I do).

Next, let’s look at the bolt pretension definition.  We start with a named selection of the face where the bolt pretension will be applied:


Next, we create our original bolt pretension load:


I’ve setup my bolt pretension to solve for a 100N axial load in load step 1 and then lock the solved-for relative displacement in for load step 2.  We select the bolt pretension in the tree, then select the object generator:


Select the named selection that contains the bolt faces, and hit generate:


This is incredibly useful for bolt pretension for two reasons.  The first reason is obvious…it significantly cuts down on the amount of work you need to do for large bolt patterns.  The second reason…you can only make changes to bolt pretension objects one at a time.  By that, I mean you cannot multi-select all your bolt pretensions and change the load and step behavior (e.g. change load to 200N, open in load step 2, etc). 


If you select all the bolt pretensions, the changes you make in the tabular data window are only applied to the first selected object.  All other bolt pretensions are kept the same.  So if you suddenly realize the pretension was setup incorrectly, it’s best to delete all but one of the pretension object, make the necessary changes, then duplicate it.  That way you can be sure all the bolt pretensions are correct (unless you’re simulating a bolt opening up…then ignore). 

One very important thing to note is that the object generator is not parametrically linked to anything.  If I go back and change the number of holes/bolts/etc in my model, I may need to re-generate the duplicated joints/bolts/etc.  The named selections should update just fine, assuming you didn’t open the hole up bigger than the selection tolerance.  I would recommend deleting all but the original joint/bolt pretension and just re-create everything after the CAD update (this may actually speed up the CAD transfer as it’s not trying to link up incorrect entity IDs).

Hopefully this will save you some time/frustration in your next analysis.  The documentation in R15 can be accessed here:  help/wb_sim/ds_object_generator.html

Sifting through the wreckage: Element Birth and Death in Workbench

So the WebEx that expanded upon my article about load vs. sub-step in Workbench ended with me getting booted from the teleconference and unable to rejoin.  I handled as many questions as possible through the chat window, but one of them required a bit more than I was willing to answer via chat window.  That question was “do you have an example of element birth/death using command snippets”. 

It may not have been that bad…and I might not look that cool


I’ll first start by going over element birth and death.  This functionality allows you to remove the stiffness of groups of elements from a load-step (clarification:  it technically reduces the stiffness by the value defined with the ESTIF command, which defaults to 1E-6).  I’ve typically seen it used to analyze some chip-level component where you have multiple assembly steps where the component is heated, stuff poured on it, cooled, heated back up to a different temperature, and so on.  This functionality is accessed by using the ekill and ealive commands, which operate on the currently selected element set.  I should also point out that you can use these commands on contact elements to simulate assembly processes by eliminating contact interfaces from being detected from step to step (PROTIP:  not recommended for MPC-based contact).

Next, how to enact in Workbench.  The command snippets are fairly simple, the real leg work comes in selecting the elements you want to kill.  This is typically done through named selections or selecting elements by material.  The easiest way to use named selections is to scope the named selection to a body:

Note the ‘part1’ is scoped to a body

When a named selection is scoped to a body, the MAPDL input file contains a component consisting of elements.  You can select these elements by using the command “cmsel,s,part1”.  If the named selection is scoped to a keypoint, line, or area, the corresponding component will consist of nodes.  You can ‘fight’ your way to the attached elements by doing a “esln” after you select the component (repeat as many times as you like in a *do loop).  This can get confusing if you’re using surface bodies (meshed with shells) as the surface and body ‘look’ like the same thing…just realize that it’s all in the details (window).

The other way (that I’m willing to discuss in this article) to select the elements is to ‘tag’ the material number in another command snippet.

RMB on the geometry and insert a command snippet
Note the documentation at the top of the snippet
So the trick here is reading the auto-inserted documentation (I know…no one ever reads the instructions).  It states that if you want to interact with the material for this body to use the parameter “matid”.  In the input deck, when the elements for this body are being read in, there is a scalar parameter named “matid” that contains the material property number.  All we need to do is transform that temporary value (it will increment up by one if there was another body after this) by assigning it to a different scalar.  As seen above, all I did was write “part2=matid”.  If we want to select these elements all we need to do is “esel,s,mat,,part2”. 
Now I’ll put this all together into a simple thermal expansion model.  A simple 3-2-1 displacement constraint on 3 corners will be used, and I’ll kill off both inserts.  Here’s the command snippets:
Like I said…the commands are simple

One thing that might happen is the auto-solver settings will have the inappropriate settings to properly support element birth death.  If that happens, you’ll get the dreaded “an unknown error has occurred” in the message window.  Looking into the ‘Solution Information’ window will then show:

Also note the element selection status, the selection logic worked!
So we’ll modify the command snippet using the error suggestion:
Happy now solver?

Here’s a comparison of the results with the command snippet active vs inactive:

Element death results
Standard results

Now if you want to bring elements back into the model, you just need to insert a command snippet and scope it to the proper load step:

Solver Settings
Ekill Command Snippet Details
Ealive Command Snippet Details

The second command snippet just needs to contain the command “ealive,all” in order to bring everything back.  If you want to only bring back part of the model use the same selection logic as before.  I’m not going to show any results, as everything is linear, it’s late, and my dog isn’t very happy about me writing this article.  Hopefully you get the point.

In conclusion, some basic knowledge of MAPDL selection logic and load-step options within Mechanical, you can easily incorporate element birth and death into your model. 

You don’t wanna step to this: Breaking down Loadsteps and Substeps in ANSYS Mechanical

Did you know Warren G is still alive?!?  I obviously confused Nate Dogg with Warren G.  How embarrassing.  Anyways, on to the topic at hand…regulators, mount up.

Nate Dogg and Warren G using ANSYS…what’s next?


So what exactly is the difference between a load-step and a sub-step?  A load-step should be thought of as a set of constraints/loads that are being solved for while the sub-steps are how you transition from one loading environment to the next. 

image2 image3
Blue = Sub-step, Red = Load-step Solved for loading

So as shown in the graph above, at time=1 (for a static run time is meaningless, think of it more as a % of applied load where 1=100%) the applied load is 10 pounds.  Since it’s the first load-step, all applied values are ramped from 0 (by default), and there are 10-equal interval sub-steps that allow the solver to get from 0 to 10.  For load-step 2, which has an end time of 2 (load-steps must have increasing end-times), only 4 sub-steps that get progressively larger were used.  We’ll get into how that works, but the important take-away is that load-step 2 starts at the end of load-step1. 

Within Mechanical, you define both load-step and sub-step controls in the ‘Analysis Settings’.

Red = Load-step, Blue = Sub-step

By default the number of steps in an environment is 1, and the solver has control over how the loads are ramped.  As soon as you increase the number of steps you will see this reflected in the ‘Tabular Data’ window for any applied load or constraint.

image5 image6
Single Load-step Defined Two Load-steps Defined

When you first start defining the load for a multi-load-step analysis, Mechanical assumes that the loading will remain constant for all subsequent steps.  This is indicated by an ‘=’ sign shown in the tabular data.

Mechanical assumes a constant value for LS2

So after you’ve gone through and defined an assembly loading process, large deflection plastic analysis to determine permanent set, or whatever else your heart desires…you can go back to define how the loads are ramped from one step to the next. 

Toggling the ‘Auto Time Stepping’ to ‘On’ gives you even more options.

Auto Time Step = On

You have the ability to define the ramping controls either by number of sub-steps or time.  Both represent the same thing, just presented through a different paradigm.

Not to be confused with a pair-of-dimes…(I’ll be here all night, make sure you tip the wait staff)

Before I get into the difference between sub-step and time, I’ll touch on the Initial/Minimum/Maximum values (note the following explanation is valid for the sub-step paradigm).  The initial value is the initial ramping value used to start off the current load step.  If the solver was able to converge easily, it can increase the load increment until it hits the ‘minimum’ sub-step value.  If the sub-step was difficult to solve, or did not solve at all, the solver can reduce the increment and try again. 

Assuming the end time of the load step is 1, here are equivalent sub-step controls (sub-step vs time) listed next to what the actual load increments are:

Equivalent Settings Assuming End Time=1, Actual Load increments shown on right

One thing to note is that if you were to change the end time from 1 to 2, the sub-step-method would still ramp by the exact same amount for each sub-step whereas the time-method would ramp it slower.  Obviously if you are running a transient analysis these controls become very important as they determine what response frequencies you’ll pickup from your structure.  The documentation recommends a time-step size of (1/20*f), where f is the highest frequency assumed to contribute to the response.  If your time-steps are too large, you’ll miss the higher frequency content that could be more damaging.

So now you’re probably thinking “great, so now what?”.  First…watch that tone mister.  Second, this should be one of the first places you should turn when you run into model convergence issues.  If a model is poorly constrained you can run a first load-step with additional constraints and then ‘release’ it once the model has converged.  If you have a model held in place purely by contact you can run an initial no-applied-load-step to allow the contacts to ‘settle down’ and properly engage.  If you have a model that fails due to excessive distortion or accumulated plastic strain you can increase the number of sub-steps to ramp the loads slower.  Or you could use this information to create some fairly complex loading environments.

I’ll be going over all of this information and more (activating/deactivating loads, command snippet use, etc) in the upcoming PADT Webinar being held on November 17th.  Hope to see you there.

Using the ‘Identifier’ for Mechanical Post-Processing

Wow, how time flies.  I wrote an article ~5 weeks ago where I discussed User Defined Results in ANSYS Mechanical.  One of the comments on that blog concerned being able to operate on results from multiple load steps, “e.g. stress in step 2 minus stress in step 1”.  I responded that yes you could, and then like an idiot stated I would have another article written in “a week or so” detailing how to do this.  My apologies Kjetil, I’m just now getting to this.  Please don’t cancel your membership in the “Doug Oatis B-Movie + ANSYS Trick Fan Club” (I’d hate to be the only member left, plus your dues are non-refundable).


Do you know how exhausting it is to party like Motley Crue…by yourself?!?

Anyways…back on topic.  The ‘identifier’ is a line available in the Details Window for any result item.


You can type in any kind of name in the cell to the right.  Note that you need to enter the name in before you evaluate the result item, or else you will see that the right cell is gray (meaning you cannot edit it).  If this happens, simply RMB on the result item in the tree and select ‘Clear Generated Data’.  That will empty the ‘bucket’ of that result item and let you edit the details of it (it WILL NOT clear out your result file…unless you RMB on ‘Solution’).


pic2 pic3

Identifier cell after result has been evaluated

To fix, RMB and select ‘Clear Generated Data’

The benefit to using the identifier is that you can then create a user-defined result and type in an expression using these identifiers.  Here’s the documentation section that discusses the available functions:
Lots of words…but pretty intuitive function definitions
The thing to note up there is the order you define the function depends on if you’re operating off of scalars or vectors (I’ll explain below).  Let’s start out by first defining our UX and UY identifiers in our post-processing section:
pic5 pic6
X-Direction, Identifier = d_ux Y-Direction, Identifier = d_uy
After I’ve defined both of these identifiers, I insert a User Defined Result.  Next, I just type in the expression I want it to evaluate:
pic7 pic8
Going back to the issue of scalars vs arrays, let’s say I wanted to add some type of constant to one of my user defined results.  In this case let’s assume I know that there’s an additional .5-in of rigid body motion that I want to plot.  To do this, I need to understand that the identifier d_ux represents an array of information (node vs displacement).  If I want to add a scalar (.5), I need to enter the expression d_ux+.5 (NOT .5+d_ux). 
If I had multiple load-steps, I could scope a stress result to a specific time-point and then perform a similar operation.  That would give me the stress increase due to the load change in between load-steps.
pic9 pic10 pic11
The thing to watch out here is to make sure that you stay consistent in what you’re operating on.  Sure you can add stress and displacement together, but that’s not really going to get you anywhere.
pic12 nobel-medal
d_ux*10000+d_seqv…everyone knows that [in]+[psi]=[Oatis] For outstanding achievement in the field of flat-plate-with-hole-in-it analysis
Also make sure that other details of identifiers you’re combining are consistent (e.g. coordinate system, integration option, etc).
For all those MAPDL users, think of this as exposing most of the *voper command within the Mechanical interface.  The main difference is that you don’t have to worry about defining your array size, and it’s incredibly easy to get the data out (RMB > Export…rather than fighting your way through fortran or C formatters).

Using User Defined Results in ANSYS Mechanical

I first started contemplating this article several weeks ago, and I was planning on somehow working in a Jersey Shore reference.  But now that I’ve relocated to Colorado and am recovering from a climbing trip that was a bit above my ability, my creative juices are a little low (they were used up trying to improvise my way up an overhanging roof pitch).

Hmm…I’m noticing there aren’t a lot of foot-holds to get me over there, prussik to the rescue!

Anyways, User Defined results were first introduced in R12 to grant the user access to element table items. 


When you insert a user-defined result, you are required to fill in the ‘expression’ line in the details window. 


Just like Johnny 5, ANSYS needs input

You can look up everything that’s available through the documentation, but we all know that no one reads the instructions.

Reading is boring…I’ll wait until the movie comes out, I hear it stars the guy who voiced Johnny 5

There’s a much easier way to auto-populate the ‘expression’ line…the Worksheet view!  To access this, first click on the ‘Solution’ branch and then select ‘Worksheet’ (tab in R12, button in R12.1 and newer).  This will show you a list of all the user defined result expressions.  Find one you like, right-mouse-click on it and select ‘Create User Defined Result’. 


                                                               That’s more like it

This will insert a ‘User Defined Result’, the only work you need to do is scope it to a body (if necessary).  The only ‘tricky’ part of this process is that you need to solve the model first before using the Worksheet view.  This is because before the model has been solved, Mechanical doesn’t know what is in the result file.  So if the worksheet view is blank or grayed out, it’s because you haven’t solved the model.

So what’s the benefit of using the User Defined Results?  Say you wanted to look at total strain, kinetic energy, or reaction force contour plots…just to name a few.  In order to view any of those, you would either have to open the .rst file in MAPDL or use the User Defined Result.

Left = FX, Right = Total Strain
Here’s a quick description of the ‘headers’ available on the Worksheet tab. 
U Displacement
S Stress
EPTO Total Strain
EPEL Elastic Strain
EPPL Plastic Strain
EPTT Thermal Strain
ENFO Element Nodal Reaction Forces
NDIR Nodal Orientation Values
There are more headers that are listed in the documentation (I know, we all agreed that was boring).  However if you’re looking for items stored in the NMISC or SMISC (for ‘regular’ or contact elements), those are accessible provided you properly format the expression line.
So now let’s go through an example where we actually use this functionality.  A customer called in asking how to calculate the volume of a part above a specified stress level.  Interesting question…
First we create a user defined result and use the ‘VOLUME’ expression.  So we’re half-way there.  Next, we need to understand about how the results are stored for a result item in the ‘Solution’ branch.  Each contour plot is actually a vector in the form of element/node vs result.  You can see this for yourself by right-mouse-clicking on the item in the tree and selecting ‘export’.  So right now we have a vector defined of element vs volume.  Now we just need another listing of element vs stress. 
When you create a stress result in Mechanical, the default behavior is to show the nodal-stress, which represent the average of the adjacent elements.  That’s not what we want.  If we look into the ‘Integration Point Results’ we see there are more options.  Element mean seems like it might work for us, but when we export it, we see that it’s still reporting stresses at the node, only now it’s using a different integration scheme.
pic9 pic10
Averaged Elemental Mean

In order to access the average stress value of the element (not node), we need to use the User Defined Results.  We’ll ask to evaluate the expression seqv (von Mises) and set the integration option of using the elemental mean.


Now when we export that result item we get what we want…element vs stress:


Now we just need to export both vectors (volume and stress), then copy/paste/sort/sum and you’re done.  Don’t forget the most important step…billing for 4 hours of post-processing work.

Long story short, all you MAPDL users who have been complaining about not being able to access element tables should take a look at the User Defined functions. 

Mapped Meshing–Pt Deux

Eric Miller wrote a nice article back in February explaining the basics of using the mapped face meshing control available within ANSYS Workbench.  Now…it would take a special kind of man to tell one of the directors of the company he works for that well…he just didn’t do a good enough job explaining it.  Lucky for you all, I’m just that kind of man.  “I have a different brain; I have a different heart; I got tiger blood, man.” – Charlie Sheen

CaptureI honestly thought my Stallone references were my best…how wrong I was

First of all, let’s start by discussing some behind-the-scenes operations being done.  When you specify a side-vertex, the mesher internally concatenates the adjacent lines together to map the divisions of one block to another.  So just by changing the side-vertex, you can ‘spin’ the mesh orientation around a given block.  The images below show the difference as you pick different ‘side’ nodes.  I had the local 3rd grade class draw lines over the map mesh source/target, divisions get mapped between same color lines.

You caught me…I never passed 3rd grade art class

So if we look at this a different way, the mapped face meshing is creating some virtual edges while still preserving the vertices for future use (e.g. applying displacements/forces).  However, let’s say we really wanted to  control some of the mapped divisions.  We can do this using actual virtual topology to merge AND split edges (new feature in R13).

Here’s a picture of Eric’s example.  It looks good enough, but for my discerning tastes I would prefer to have all of the divisions above the red dashed line match up, rather than having the divisions meander across the surface (technically speaking).

Isn’t it cute when managers try and use ANSYS?
With a little work, we can get the following:



To get this, we just need to use some virtual topology tricks to split and combine the vertical edges.  This can be done by inserting a virtual topology branch, available on the context toolbar when the ‘Model’ branch is highlighted.  You then have the option of creating virtual cells or splitting edges.



To insert VT, Select the ‘Model’ level When you have an edge selected, VT tools become available.  ‘Split’ functionality available at R13

To combine two lines into one, simply select both of them and then click ‘Virtual’ Cell’.  If you want to split an existing edge, highlight it and select one of the split options.  If you select the ‘Split Edge at +’ it will split the line where you clicked on it:

‘+’ appears where you LMB on the edge
Once the edge is split, you can move the split location by modifying the split ratio displayed in the Details Window.
Modify ratio until you’re happy with the edge split
To get the masterpiece above, we first split the vertical lines, eyeballing the division to get the new point in-line with the bottom of the ‘notch’.  Next, we combine one of the split edges with the edge above it:
comb1 comb2
Step 1:  Split edges.  Move ratio until it’s ~horizontal with bottom of notch Step 2:  Create virtual edge from split and neighboring edge (indicated by red arrows)
Step 3:  Not shown, take long lunch and bill for 6 hours of work
The last step is just to apply a mesh edge sizing control to the proper lines:
meshc1 meshc2
Selected Edges Make sure it’s a ‘Hard’ control.  That way the mesher knows we mean business
Next just generate the mesh.  I already know what you’re thinking…there are still some regions of the mesh that are iffy
Maybe I should leave the ‘Winning’ to the experts
We can play around with some additional settings, go back and modify the geometry, get a huge headache, and ultimately leave at the end of the day frustrated (mostly because of the curved edges that need to have divisions mapped across to a straight line).  Or we can realize that maybe a free-mesh with a hex-only meshing method looks just as pretty.


Looks good to me!

Long story short….

  • Use new virtual topology to fine-tune the geometry to meet your mapped meshing needs
  • Anytime you’re dealing with curved edges, it may be worth your while to use a free mesh

Direct Modeling with SpaceClaim

Those keeping up with ANSYS, Inc. update presentations may have seen mention of a new product called ANSYS SpaceClaim Direct Modeler.  ANSYS SpaceClaim Direct Modeler is a  slightly modified version of the CAD package SpaceClaim (from the SpaceClaim Corporation).  It is sold by ANSYS, Inc. and can operate either as a stand-alone application or integrated into the Workbench environment.  It’s a nice combination of a slick CAD tool for use in a high-powered FEA program.


In case you’re keeping count, SpaceClaim brings the total number of geometry processing modules ANSYS offers up to 3:

The very first one is /prep7, available within ANSYS MAPDL.  If you’re using this for serious CAD work, you have way too much time on your hands.  It’s good at doing basic modifications (surface imprints, solid gluing, surface stitching) but not much else.  The nice thing about it is that you can harness APDL to create batch jobs.  I’ve seen this used heavily in board and package level semiconductor analyses for creating BGAs and all the other small parts that need to be considered.

The next module is DesignModeler.  This is the default CAD creation/manipulation/repair module within ANSYS Workbench (requires additional license).  DesignModeler (or DM as the cool kids call it) does everything except create detailed drawings.  It’s extremely useful for creating fluid domains, gluing bodies for conformal meshes in Workbench, repairing/modifying geometry, and is overall an indispensable tool for creating efficient models within Workbench. 

As I mentioned at the top, there is a new module called ANSYS SpaceClaim Direct Modeler (still waiting for confirmation that the cool kids call it SCDM, as the product is fairly new) which is an alternate CAD module within Workbench.  So what’s the difference between DesignModeler and SpaceClaim?  Glad you asked!  Here’s a 30k-ft top-level view:


DesignModeler SpaceClaim
History-Based CAD Creation Direct (Explicit) CAD Creation
Uses CAD Plug-Ins to Import Geometry Uses CAD Translators to Import Geometry
Assembling Multiple Parts is ‘Character Building’ Assembling Multiple Parts is Easy

So let’s dig in to these differences.

History vs Direct CAD Creation:

Regardless of how you create geometry, underneath the hood there’s some fairly complicated math going on to build NURB surfaces.  The overall shape of the geometry is defined by the order, control points, and knot vector in addition to all the continuity conditions that are enforced.  Now that I’ve lost your attention, the difference between history and direct CAD modeling is in how all these controls are defined.  A history-based modeler has (as you guessed) a history, typically in the form of a tree.  This means you need to have some design intent in place to have downstream features created relative to existing objects.  Long story short, this makes it easier to tweak designs while still maintaining the design intent as well as aide in any CNC machining operations (hopefully your history matches what would be performed by the machinist).

Direct modeling, on the other hand, doesn’t have a history.  It just is.  So unlike history-based modeling, you won’t run into an issue of deleting a fillet/chamfer and have downstream operations fail.  You don’t have to worry about implied datums or anything else like that.  Where the wheels fall off the direct modeling method are if you need to repeat a bunch of downstream operations.  For example, I had just completed a major defeaturing effort on a sheet-metal riveted nightmare.  The analysis showed that the current design was inadequate, so more rivets were added.  Using SpaceClaim, I can’t just go back to an upstream import and redefine a few downstream operations.  I wound up repeating the same defeaturing operations on the negative margin portion of the model, then slapped it into the existing model.  Direct modeling really shines if you’re trying to tweak the shape of a part by just pulling/pushing certain faces together, if you were using a history-based modeler you would have to base all of your operations on existing objects, which can be extremely tedious and/or impossible.  An example is shown below, where a tiny step is removed by drafting (through a ‘Pull’ operation) a face to an existing edge:


Long story short, history-based offers a good ‘turn the crank’ capabilities to recreate entire assemblies based off of a few minor tweaks.  Direct modeling skips the hassle of accidental datums and other parent/child relationships.  Direct modeling may feel like CAD without a safety net, I prefer to view it as more of a Buddhist-esque CAD system.  Stop grasping after the history tree and you’ll find enlightenment (for most situations).

CAD Plug-ins vs Translators:

This one is simple.  Plug-ins require the CAD system to be installed locally on the machine.  Translators do not.  Both SC and DM will import SolidWorks, Pro/E, and all your other favorite CAD systems.  The difference is that if you’re using DM, you’ll need to have the source-CAD tool installed as well.  If you’re using SC you can free up that disk space. 

Creating Assemblies:


For anyone who’s ever used DM to assemble multiple parts together, I feel your pain.  It essentially uses the same methodology of /prep7’s VTRAN command to translate a selected part from one coordinate system into another.  Starting at R12, you could specify translations and rotations, but you still had to know how far to move the part to place it properly.  Once you get the hang of it, it’s not hard (just tedious).  Throw in the frozen vs active (aka unfrozen) behavior, and it can make for some choice words after hitting ‘Generate’

Oh, how I’ve wished that there was a way to specify a mate/align/insert constraint.  In comes SpaceClaim, like a knight in shining armor (or like Will Ferrell as a lumberjack in Stepbrothers…I’ll let you look it up on youtube).  Super easy to assign constraints and assemble your parts.  Like most other operations in SC, it’s intuitive.  Pick two cylindrical faces and hit ‘align’ and BAM, you’ve got a coaxial constraint.  Pick to faces and hit ‘align’, KAPOW, you’ve got an align/mate constraint. 



On top of these things, here’s a quick list of other features.

Cross-Section Mode Easy to create cross-section views

Changes made to cross-section view propagates through entire solid (awesomely awesome if you ask me)

Keyboard Shortcuts Basic keyboard shortcuts for most common operations
Midsurfacing (DM) Extract midsurface representation and thickness for use in shell meshing
Shared Topology (DM) Ability to define multi-body parts for conformal mesh
Interference Detection Find (and fix) overlapping regions in an assembly
Multiple Tabs Ability to open a single part in its own tab.  Changes made on separate tab propagate back to assembly

(DM) represents existing features currently within DesignModeler

So, now that you’re tripping over yourself to get your hands on this new tool, where do you go to learn more?  SpaceClaim has some excellent (and free) video tutorials complete with input files.  You can access these by going to:

Then go to Support > Tutorials, and start downloading.

Finally, in an effort to leave you ‘wanting more’, here’s a sneak peak at what I’ll be doing during the Webinar:


Using the ‘Worksheet’ Page in Mechanical

One of the least used, but most powerful, features within ANSYS Mechanical is the Worksheet page.  In versions older that R12.0, this was accessed by clicking a separate tab on the Graphics Window, at R12.1 it moved to a button on the toolbar. 

What the Worksheet does is show you a tabular summary of a particular branch.  Here’s a quick summary of the ‘big items’ shown for each branch:

Geometry Branch Material, Volume, # Nodes
Coordinate Systems Origin and Axis Data for all coordinate systems
Connections Behavior, Formulation, Stiffness Update

Mesh control type, Active/Suppressed Status

Analysis Settings Solution controls for every load step
Solution Element table results available (only for R12 and newer)
Solution Information ANSYS Solver Output window

Here’s a picture showing what it actually looks like:


In addition to listing out a large amount of information, you can also sort by any column heading.  You’re probably thinking, “wow, that’s awesome…I can list and sort information about various levels of my model, but how come I can’t edit anything in the worksheet?”  Great question, and this is where the power of ‘Go To’ (see my previous article, err…blog) comes into play.  Simply select the rows that you want to edit, then Right-Mouse-Button > Go To Selected Items.  This will go through and highlight all the corresponding items in the Outline Tree.  Settings can then be changed in the Details Window, and will be propagate to all selected items. 

So let’s say you have a bunch of contact pairs in your model, some of which are defined as being frictional and need to have the same coefficient of friction applied.  Simply click on the ‘Connections’ branch, then select ‘Worksheet’, then select the ‘Type’ column to group all of the frictional pairs together. 

Next, hold down shift and do a flood-selection of all of the frictional pars, RMB > Go To Selected Item. 

Finally, type in the coefficient into the details window.  Done…all frictional contact pairs now have that value defined.

Long story short, by combining the ‘Go To’ capability with the Worksheet view, you can become the feared “über-efficient Voltron of ANSYS Users”.  Well, maybe nothing that cool, but you’ll at least got a lot of work done.

Side note:  According to Wikipedia, Voltron is owned by Sony Pictures Television.  This was a cartoon I remember watching as a kid where a giant robot was formed by connecting five robot lions piloted by the heros of the show.  I even had the toys to go along with the show, and yes, they joined together to form awesomeness in its purest form, I mean, the fists were spring-launched lion heads!!!  It was a sad day when I found that I had lost one of the lions heads…I believe that’s when my childhood officially ended.

‘Go To’…like using the LHC to find a needle in a haystack… except you don’t run the risk of creating a black hole that destroys us all.


When you couple ANSYS Workbench’s automation features, ease of use, and advances in computer resources, it typically results in some rather large models.  When I first started using ANSYS, I remember fighting tooth and nail to avoid using contact and keep the model size under 200k nodes.  Fast forward to a recent consulting job that included 70 contact regions, 30 kinematic joints, and a total model size around 700k nodes, and I barely batted an eye.

Some problems you run into with models at this size and complexity is figuring out “what am I looking at?”, “what’s connected to this?”, “why is the mesh doing that?”, just to name a few.  The brute force way to figure most of these out is to go through each tree item, one at a time, until the part you’re looking at lights up.  This is probably okay for a single component or small assembly, anything larger and it becomes a daunting task.  Luckily, there’s an easy way around this, simply click the right mouse button (RMB) and select the ‘Go To’ branch.  This will fire up the Large Hadron collider and help you find what you’re looking for (sans the risk of singularities and destruction of all mankind).

The image shown was taken in R12.1 (note that if you’re still using v11 some of these options are not available…time to upgrade!).  While most of these options seem self-explanatory, I get paid for each word I write (just kidding), so here’s a quick summary for all the options shown:

Corresponding Bodies in Tree Highlights selected body in geometry branch – allows you to change material properties of selected parts, note that you can have a vertex, line, area, or body selected…either way it’ll bring you to the ‘parent’ body
Bodies Without Contacts in Tree  Regardless of what’s currently selected, it will highlight all bodies in the geometry branch that do not have a contact pair – handy for chasing down the ‘max DOF incremenet’ error caused by an unconstrained body
 Contacts for Selected Bodies  Selects all contacts for the selected body – first place I check when I get odd stress results on my parts, typically because of an ‘accidental’ contact pair
 Contacts Common to Selected Bodies Selects only contact pairs between selected parts – Note that you must have >1 part selected or this won’t work, nice way of figuring out how two parts are connected
 Joints for Selected Bodies Similiar to ‘Contacts for Selected’, only with kinematic joints
Joints Common to Selected Bodies Similiar to ‘Contacts Common to…’, only with kinematic joints – again a very nice feature to figure out how two parts are connected
 Springs for Selected Bodies  Similiar to the ‘Contacts for…’ or ‘Joints for…’, only you guessed it, will show user-defined springs that attach to the body
 Mesh Controls for Selected Bodies Shows all mesh controls for the body currently selected – nice for answering the question “why is the mesh doing that?” type of issues

As noted in the description list, it does not matter what part of the body you have selected when you use the ‘Go To’ feature.  You can have a vertex, line, area, or the entire body highlighted.  ANSYS Mechanical understands what your selection belongs to, and takes you to the appropriate item.  So let’s say you have 5 different components that you need to change the material properties for.  Highlight a face on each body, RMB > Go To > Corresponding Bodies in Tree, then make the material change in the Details Window.  The change will be applied to all selected bodies.

The ‘Go To’ functionality is also available within ANSYS DesignModeler, the CAD creation/simplification/modification/etc moduls within Workbench.

Within DesignModeler, you have two options:

Go To Feature Takes you to where the selected feature (vertex, line, area, body) was created, handy in finding out where a surface patch or ‘stranded’ line was created
Go To Body Takes you to the body within the parts-list at the bottom of the tree window, helpful in assigning thicknesses to surface bodies or renaming parts

As noted above, I use the ‘Go To Feature’ to identify where surface patches or stranded lines (line imprinted through part of an area) come from.  Depending on the body status (active or frozen) and the filtering used for certain operations, you can accidentally create imprints in unintended regions (the new ‘Projection’ tool, available in R12, is a big help in preventing this because it doesn’t ‘care’ if a body is active or frozen).

Using the picture above, if I wanted to figure out where that circular area came from, I would select it > RMB > Go To Feature and it would highlight this operation in the model tree:

In the Details Window I would see that this Body Operation was set to ‘Imprint Faces’.

So, to summarize, there is no need to go blind and suffer from carpal tunnel when trying to find out details of your model.  Just remember the ‘Go To’ function!

As a side note, I realize that the likelihood of the LHC producing a black hole capable of destroying the universe is extremely small.  Any black holes that could be generated would be short lived, and require so little negative mass to neutralize that we need not worry.