## Thermal Submodeling in ANSYS Workbench Mechanical 15.0

If you've been following The Focus for a long time, you may recall my prior article about submodeling using ANSYS Mechanical APDL, which was a 'sub' model of a submarine.  The article, from 2006, begins on page 2 at this link:

Also, Eric Miller here at PADT wrote a Focus blog entry on the new-at-14.5 submodeling capability in ANSYS Workbench Mechanical.

Since both of those articles were about structural submodeling, I decided it was time we published a blog entry on how to perform submodeling in ANSYS Mechanical for thermal simulations.

Submodeling is a technique whereby we can obtain more accurate results in a small, detailed portion of a large model without having to build an incredibly refined and detailed finite element model of our complete system.  In short, we map boundary conditions onto a 'chunk' of interest that is a subset of our full model so that we can solve that 'chunk' in more detail.  Typically we mesh the 'chunk' with a much finer mesh than was used in the original model, and sometimes we add more detail such as geometric features that didn't exist in the original model like fillets.

The ANSYS Workbench Project Schematic for a thermal solution involving submodeling looks like this:

Figure 1 – Thermal Submodeling Project Schematic

Note that in the project schematic, the links are automatically established when we setup the submodel after completing the analysis on the coarse model as we shall see below.

First, here is the geometry of the coarse model.  It's a simple set of cooling fins.  In this idealized model, no fillets have been modeled between the fins and the block.

Figure 2 – Coarse Model Geometry, Idealized without Fillets

The boundary conditions consisted of a heat flux due to a  thermal source on the base face and convection to ambient air on the cooling fin surfaces.  The heat flux was setup to vary over the course of 3 load steps as follows:

1                      0.2

2                      0.5

3                      0.005

Thus, the maximum heat going into the system occurs in load step 2, corresponding to 'time' 2.0 in this steady state analysis.

Figure 3 – Coarse Model Boundary Conditions – Heat Flux and Convection

The coarse model is meshed with relatively large elements in this case.  The mesh refinement for a production model should be sufficient to adequately capture the fields of interest in the locations of interest.  After solving, the temperature results show a max temperature at the base where the heat flux is applied, transitioning to the minimum temperature on the cooling fins where convection is removing heat.

Figure 4 – Coarse Model Mesh and Temperature Results for Load Step 2

Our task now is to calculate the temperature in one of these fins with more accuracy.  We will use a finer mesh and also add fillets between the fin and base.  For this example, I isolated one fin in ANSYS DesignModeler, did some slicing, and added a fillet on either side of the base of the fin of interest.

Figure 5 – Fine Model (Submodel) Isolated Fin Geometry and Mesh, Including Fillets at Base

ANSYS requires that the submodel lie in the exact geometric position as it would in the coarse model, so it's a good idea to overlay our fine model geometry onto the coarse model to verify the positioning.

Figure 6 – Submodel and Coarse Model Overlaid

Figure 7 – Submodel and Coarse Model Overlaid, Showing Addition of Fillet

The next step is to insert the submodel geometry as a stand-alone geometry block in the Project Schematic which already contains the coarse model, as shown in figure 8.  A new Steady-State Thermal analysis is then dragged and dropped onto the geometry block containing the submodel geometry.

Figure 8 – Submodel Geometry Added to Project Schematic, New Steady-State Thermal System Dragged and Dropped onto Submodel Geometry

Next, we drag and drop the Engineering Data cell from the coarse model to the Engineering Data cell in the submodel block.  This will establish a link so that the material properties will be shared.

Figure 9 – Drag and Drop Engineering Data from Coarse Model to Submodel

The final needed link is established by dragging and dropping the Solution cell from the coarse model onto the Setup cell in the submodel.  This step causes ANSYS to recognize that we are performing submodeling, and in fact this will cause a Submodeling branch to appear in the outline tree in the Mechanical window for the submodel.

Figure 10 – Solution Cell Dragged and Dropped from Coarse Model to Submodel Setup Cell

After opening the Mechanical editor for the submodel block, we can see that the Submodeling branch has automatically been added to the tree.

Figure 11 – Submodeling Branch Automatically Added to Outline Tree

After meshing the submodel I specified that all three load steps should have their temperature data mapped to the submodel from the coarse model.  This was done in the Details view for the Imported Temperature branch, by setting Source Time to All.

Figure 12 – Set Imported Temperature Source Time to All to Ensure All Loads Steps Are Mapped

Next I selected the four faces that make up the cut boundaries in the submodel and applied those to the geometry selection for Imported Temperature.

Figure 13 – Cut Boundary Faces Selected for Imported Temperature

As mentioned above, the Imported Temperature details were set to read in all load steps by setting Source Time to All.  The Imported Temperature branch can now be right-clicked and the resulting imported temperatures viewed.  I also inserted a Validation branch which we will look at after solving.

Figure 14 – Setting Source Time to All, Viewing Imported Temperature on Submodel

Any other loads that need to be applied to the submodel are added as well.  For this model, it's convection on the large faces of the fin that are exposed to ambient air.

Figure 15 – Submodel Convection Load on Fin Exposed Faces

Since there are three load steps in the coarse model and we told ANSYS to map results from all time points, I set the number of steps to three in Analysis Settings, then solved the submodel.  Results are available for all three load steps.

Figure 16 – Submodel Temperature Results for Step 2 (Highest Heat Flux Value in Coarse Model)

Regarding the Validation item under the Imported Temperature branch, this is probably best added after the solution is done.  In my case I had to clear it and recalculate it.  Validation can display either an absolute or relative (percent difference) plot on the nodes at which loads were imported.  Figure 17 shows the relative difference plot, which maxes out at about 6%.  The validation information as well as mapping techniques are described in the ANSYS Help.

Figure 17 – Submodel Imported Temperature Validation Plot – Percent Difference on Mapped Nodes

Looking at the coarse model and submodel results side by side, we see good agreement in the calculated temperatures.  The temperature in the fillets shows a nice, smooth gradient.

Figure 18 – Coarse and Submodel Temperature Results Showing Good Agreement

Hopefully this explanation will be helpful to you if you have a need to perform submodeling in a thermal simulation in ANSYS.  There is a Thermal Submodeling Workflow section in the ANSYS 15.0 Help in the Mechanical User's Guide that you may find helpful as well.

## Serial and Parallel ANSYS Mechanical APDL Simulations

There are times when you want to study the effects of varying parameters.  If you have an existing MAPDL script that is parameterized, the following procedure will allow you to easily run many variations in an organized manner.

Let’s assume a parameterized MAPDL macro called build_solve that does something you want to simulate many times and has 2 variables called power and scale which are set with argument 1 and 2 respectively.  Running this macro with the classic interface, with power=30 and scale=2.5 would look like this:

build_solve,30,2.5

Next, create a MAPDL macro to launch all of the simulations.  This script could be named control.mac.  The first thing to do here is to create arrays of your parameters and assign values to them.  This example will vary power and scale.  Here are the arrays of values that will be passed to build_solve:

*dim,power,array,4

power(1)=10,20,40,80

*dim,scale,array,6

scale(1)=1,2,3,5,10,20

Most of the control.mac commands will be put inside of nested *do loops.  There will be a *do loop for each of parameters being varied.

*do,ii,1,4

*do,jj,1,6

Next, use *cfopen to set up the arguments to be passed to build_solve.  Each time through the *do loops will create a new run1.mac

*cfopen,run1,mac

a=power(ii)

b=scale(jj)

*vwrite,a,b

build_solve,%G,%G

*cfclose

One of the key features of this approach is to run anywhere and build directories below the working directory.  Use the /inquire command to store the current directory name.

/INQUIRE,dir_,DIRECTORY

Use *cfopen to create a string that will be used for the directory name.  By using the variables as part of the string, the directories will have unique names.  A time or date stamp could also be included in this string.  This macro is executed immediately to create the string dirnam for use in the commands subsequently.

*dim,power,array,4

*cfopen,temp1,mac

*vwrite,a,b

dirnam='power_%G_scale_%G'

*cfclose

/input,temp1,mac

Eventually, the resulting directory structure will look something like the image below.  Each directory will contain a separate simulation with the arguments of power and scale set respectively.

The last *cfopen creates a windows batch file which will (when executed)

1. Create the new directory

2. Copy all of the macro files from the working directory into the new directory (including run1.mac)

3. Change into the new directory using CD

4. Launch ansys in batch mode, in this case using a gpu and 12 cpus, using the run1.mac input and outputting to f.out

5. Change back to the working directory (ready to do it all again)

The code for the windows batch file is:

*cfopen,rfile,bat

*vwrite,dir_(1),dirnam

MKDIR "%C\%S"

*vwrite,dir_(1),dirnam

COPY *.mac "%C\%S"

*vwrite,dir_(1),dirnam

CD "%C\%S"

*vwrite,

"C:\Program Files\ANSYS Inc\v150\ansys\bin\winx64\ansys150" -b -acc nvidia -np 12 -i run1.mac -o f.out

*vwrite,dir_(1)

CD "%C"

*cfclose

The last step is to run the windows batch file.  /sys is used to make this system call.  If the simulation is not well parallelized and you have enough licenses available, run the simulations in low priority mode immediately.  This will launch all of your simulations in parallel:

• /sys,start /b /low rfile.bat

If the model is well parallelized (in other words, it will use your system’s gpu/cpus/RAM efficiently) or you only have 1 license available, launch the batch files in high priority mode and use the /wait option which will insure that windows waits for the job to finish before launching the next simulation.

• /sys,start /b /high /wait rfile.bat

You can download and view the examples control.mac and build_solve.mac from this zip file: build_solve-control-macros.zip

## ANSYS 2015 Hall of Fame Announced – Los Alamos National Labs and SynCardia Models are Finalists

Every year for a while now ANSYS, Inc. has chosen models made by users of the ANSYS software tools for their Hall of Fame.  This year had some very cool models across CFD, Structural, and Electromagnetic – including some great Multiphysics applications. Visit the ANSYS website to see all the winners here.

The three commercial winers of "Best in Show" were varied but powerful examples of how simulation can be used to improve performance and reliability of products:

Andritz Hydro used ANSYS Mechanical to model their assemblies to see if replacing welds with bolted joints would reduce weight and cost while keeping reliability.  They used sub-modeling, bolted joints, and contact.

BRP used ANSSY CFX, ICEM CFD, and Mechanical to capture the forces caused by cavitation on their outboard marine engine. This engine pushes a boat at 75MPH (!!!) through the water, so yes, they get cavitation.  They used ICEM CFD for meshing, CFX to predict the cavitation and capture the cavitation loading, and Mechanical to see how the loading impacted the gear train and shafts. They were able to obitmize the desgin quickly using this process.

Spinologics used ANSYS Mechanical APDL to model the process of using a rod to straighten a deformed spine (scoliosis). They use the scriptability of the APDL to automate the creation of the models.  Very cool stuff.  Check out the video on the link.

We also want to mention two customers that were involved as Finalists.

 SynCardia is often mentioned in this blog because, well, they make a frick'n artificial heart that saves lives every day.  We modeled an early iteration on the heart as a multiphysic problem probobly 5 or 6 years ago, it could have been longer ago. More recently Stony Brook University and the University of Arizona did a much more detailed model in ANSYS Fluent that looks at not just pressure and velocity, but Platelet dispersion patterns in the artificial heart.  Check out the video here:  https://storage.ansys.com/hof/2015/video/2015-stonybrook.mp4 Los Alamos National Labs is another long time PADT customer and we were fortunate enough to be involved in the study that was recognized as a finalist. They used ANSYS Fluent to model something called vortex-induced motion or VIM in off-shore oil rigs.  Basically waves hit the platform and create these big swirling vortices.  These in turn put loads on the structure that can sometimes be very large.  The purpose of this study was to find a way to accurate predict VIM with simulation so they could then evaluate various solutions. A true Fluid-Solid Interaction (FSI) and because of the size of the structures and all that turbulence, High Performance Computing (HPC) problem. We hope to publish a paper on some related work this year… watch this space for more.

This competition is a great way to see what others are doing, and if you submit your models, to show off what you have done.  Contact your ANSYS rep to learn more or drop us a note.

## ANSYS Icepak: Diverging Residuals, Find and Fix the Problem!

Over the past week I have found myself dealing with a stubborn natural convection ANSYS Icepak model with convergence plots that would have been more aptly named divergence plots that looked like this:

In this post I’m going to show you the process I went through to find and fix my problem.

First, a few things to know about Icepak:

• Many of the problems associated with your Icepak model are very likely mesh related.

• If the bad elements are in a solid, you are probably OK, but if they are in the fluid, watch out!!

So, what is the conclusion? I have a mesh problem.

Second, how do you find the problem?

According to the above “convergence” plot, the continuity equation is diverging (or to my frustrated, on-a-deadline mind, it was GOING CRAZY). Well, a diverging continuity equation indicates that I have a conservation of mass problem. After consulting with one of my more experienced colleagues, Clinton Smith, he suggested that I do the following to work towards pin-pointing the problem:

• Plot the gravity direction velocity (in my case, this was Uy)

• Look for the Minimum and Maximum Uy locations in the model

Plotting Uy along a cut plane produced this:

As Clinton thought, plotting Uy instantly showed me the section of my model that was producing un-physical results. Next, I looked for the maximum and minimum velocity locations because this would further show me problems.

Next, I need to determine why this area of my model is the problem. Like I said above, it is likely a mesh problem. In the Mesh Control panel under the Quality tab checking the Face alignment values often help to locate very bad elements:

Clicking on the pink block above displays the elements in the graphics window and it was instantly obvious that my problem was due to distorted elements in my area of interest:

When I look at these elements with a perspective of my model geometry I see that the elements are obviously in the fluid domain:

I have found my problem.

Third, how do I fix the problem? Well, the location of my bad elements happens to lie on a CAD body in Icepak. This means that I am limited in my ability to control the mesh on the actual body. So, though there are likely multiple ways that this problem could be solved, I had the idea to create an air block in the area above that I could much more easily control from a meshing perspective. Having a real Icepak primitive in that space would force the mesher to conform to the boundary of the CAD body.

Like I thought, the air block worked!

I should note that in order to get the mesh to conform exactly, I had to put the air block into its own meshed-separately assembly. And now my residuals look much better!

Summary:

• Diverging continuity residuals indicate a conservation of mass problem

• Plot velocities to locate problem region

• Plot min/max velocity to further identify problem

• If bad elements are in the fluid region, they must be fixed

• Consider creating an air block in the region of interest to more finely control the mesh

## Configuring Laptop “Switchable” Graphics for ANSYS Applications

A lot of laptops these days come with “switchable” graphics.  The idea is that you have a lower capability but also lower power consuming ‘basic’ graphics device in addition to a higher performing but higher power demand graphics device.  By only using the higher performance graphics device when it’s needed, you can maximize the use time of a battery charge.

A lot of the ANSYS graphics-intensive applications may need the higher end graphics device to display and run correctly.  In this article, we’ll focus on the AMD Firepro as the “higher end” graphics, with Intel HD graphics as the “lower end”.  We will show you how to switch to the AMD card to get around problems or errors in displaying ANSYS user interface windows.

The first step is to identify the small red dot graphics icon at the lower right in the task bar:

Figure 1 – AMD Catalyst Icon

Next, right click on the icon to bring up the AMD Catalyst Control Center, if you don’t see the switchable option as shown two images down.

Figure 2 – AMD Catalyst Control Center Right Click Menu Pick

Right click on the same icon again, if needed to select “Configure Switchable Graphics,” as shown here:

Figure 3 – Select “Configure Switchable Graphics” via Right Click on the Same Icon

In the resulting AMD Catalyst Control Center window, click on the Add Application button.

Figure 4 – AMD Catalyst Control Center Window

Next browse to the application that needs the higher end graphics capability.  This might take a little trial and error if you don’t know the exact application.  Here we select ANSYS CFD-Post and click Open.

Figure 5 – Selecting appropriate executable for switchable graphics

Finally, select the High Performance option from the dropdown for your chosen executable, then click the Apply button.

This should get your graphics working properly.  Again, the reason we have the two graphics choices is to allow us to better control power consumption based on the level of graphics that are needed per application.  Hopefully this article helps you to choose the proper graphics settings so that your ANSYS tools behave nicely on your laptop.

## Getting to know ANSYS – SIwave

This video is an introduction to ANSYS SIwave – an analysis tool for Integrated Circuits and PCBs

## ANSYS Workbench Installations and RedHat 6.6 – Error and Workaround

We were recently alerted by a customer that there is apparently a conflict with ANSYS installations if Red Hat Enterprise Linux 6.6 (RHEL 6.6) is installed. We have confirmed this here at PADT. This effects several versions of ANSYS, including 15.0.7, 14.5, and 14.0. The primary problem seems to be with meshing in the Mechanical or Meshing window.

The windows errors encountered can be: “A software execution error occurred inside the mesher. The process suffered an unhandled exception or ran out of usable memory.” or “an inter-process communication error occurred while communicating with the MESHER module.”

The error message popup can look like this:

or

Note that the Platform Support page on the ANSYS website does not list RHEL 6.6 as supported. RHEL is only supported up through 6.5 for ANSYS 15.0. This is the link to that page on the ANSYS website:

That all being said, there is a workaround that should allow you to continue using ANSYS Workbench with RHEL 6.6 if you encounter the error. It involves renaming a directory in the installation path:

In this directory:

/ansys_inc/v150/commonfiles/MainWin/linx64/mw/lib-amd64-linux/

Rename the folder ‘X11’ to ‘Old-X11’

After that change, you should be able to successfully complete meshes, etc,. in ANSYS Workbench. Keep in mind that RHEL 6.6 is not officially supported by ANSYS, Inc. and their recommendation is always to stick with supported levels of operating systems. These are always listed in the ANSYS Help for the particular version you are running as well as at the link shown above.

Since the renamed directory is contained within the ANSYS installation files, it is believed that this will not affect anything else other than ANSYS. Use at your own risk, however. Should you encounter one of more of the errors listed above, we hope this article has provided useful information to keep your ANSYS installations up and running.

## Welcome to the PADT IT Department now build your own PC

[Editors Note: Ahmed has been here a lot longer than 2 weeks, but we have been keeping him busy so he is just now finding the time to publish this. ]

I have been working for PADT for a little over 2 weeks now. After taking the ceremonial office tour that left me with a fine white powder all over my shoes (it’s a PADT Inc special treat). I was taken to meet my team, David Mastel – My Boss for short, who is the IT commander & chief at PADT Inc. and Sam Goff – the all-knowing systems administrator.

I was shown to a cubicle that reminded me of the shady computer “recycling” outfits you’d see on a news report highlighting the vast amounts of abandoned hardware; except there were no CRT (tube) screens or little children working as slave labor.

This tradition started with Sam, then Manny, and now it was my turn taking this rite of passage. As part of the PADT IT department, I am required by sacred tradition to build my own desktop with my bare hands – then I was handed a screwdriver.

My background is mixed and diverse but mostly has one thing in common. We usually depended on pre-built servers, systems and packages. Branded machines have an embedded promise of reliability, support and superiority over the custom built machines.

1. What most people don’t know about branded machines is that they carry two pretty heavy tariffs.
2. First, you are paying upfront for the support structure, development, R&D, supply chains that are required to pump out thousands of machines.
3. Second, because these large companies are trying to maximize their margins, they will look for a proprietary cost effective configuration that will:
1. Most probably fail or become obsolete as close as possible to the 3-year “expected” life-span of computers.
2. Lock users into buying any subsequent upgrade or spare part from them.

Long Story short, the last time I fully built a desktop computer was back in college when a 2GB hard disk was a technological breakthrough that we could only imagine how many MP3’s we could store on it.

## The Build

There were two computer cases on the ground, one resembled a 1990 Mercury Sable that was at most tolerable as a new car and the other looked more like 1990 BMW 325ci a little old but carries a heritage and potential to be great once again.

So with my obvious choice for a case I began to collect parts from the different bins and drawers and I was immediately shocked at how “organized” this room really was. So I picked up the following:

There are a few things that I would have chosen differently but were not available at the time of the build or were ridiculous for a work desktop would be:

• Replaced 2 drives with SSD disks to hold OS and applications
• Explored a more powerful Nvidia card (not really required but desired)

So after a couple of hours of fidgeting and checking manuals this is what the build looks like.

(The case above was the first prototype ANSYS Numerical Simulation workstation in 2010. It has a special place in David’s Heart)

## Now to the Good STUFF! – Benchmarking the rebuilt CUBE prototype

ANSYS R15.0.7 FEA Benchmarks

Below are the results for the v15sp5 benchmark running distributed parallel on 4-Cores.

ANSYS R15.0.7 CFD Benchmarks

Below are the results for the aircraft_2m benchmark using parallel processing on 4-Cores.

This machine is a really cool sleeper computer that is more than capable at whatever I throw at it.

The only thing that worries me is that when Sam handed me the case to get started, David was trying –but failed- to hide a smile that makes me feel that there is something obviously wrong in my first build and I failed to catch it. I guess I will just wait and see.

## ANSYS Workbench Mechanical: The Body Views Features Can Be a Huge Time Saver

The following is a story of discovery. The discovery of an ANSYS feature that has been around since at least ANSYS14! How is that possible you ask? The PADT team members are the ANSYS experts of the Southwest, how could they have missed this! And we would agree with you on the former, but even we overlook some of the most fundamental and helpful features. And you are going to want to store this one away, so copy the link, bookmark the page, or make a mental note with your photographic memory and file it under productivity enhancer.

After all of that hype, what could I possibly be going tell you that is so earth shattering. Well, it’s not really a secret if you read the title but I’ll let you be the judge of this little nugget’s seismic impact. Now, if you’ll indulge me, I’ll set the stage.

A couple of weeks ago, I was compiling a report of an ANSYS Mechanical analysis. One of the report sections required details of the contact definition between each part. I hunkered down to spend what I thought would be a tedious hour of documenting each contact expecting to use a procedure that consisted in some form of isolating the two bodies of interest, capturing screenshots of the two parts in various relation to each other in order to adequately represent the contact context. As I sat looking at the screen creating my plan of attack, I thought to myself, I wish there was an ANSYS feature that would automatically isolate the two connected bodies so that I would not have to go through the finger numbing (or should I say finger cramping) task of “hiding all other bodies” (even though this is one of my other favorite features). As soon as the thought flashed through my mind, my eyes moved up the screen and, above the Mechanical graphics window, I saw it.

Body Views! The star of my post. You will find our elusive capability in the painfully obvious Connections Context Toolbar:

When I clicked on it, the graphics window transformed from this:

To this:

The relevant bodies were isolated into two different views, contact and target. I was elated. My task of manually isolating the bodies and adjusting the views while intermediately capturing the desired screens now turned into a joyful, albeit nerdy, moment of discovery. With some experimenting, I easily found that each view can be adjusted independently, unless of course you would like them all to move together. You can accomplish this by selecting the Sync Views option:

• Use it to easily isolate contact/target body
• Use it to easily identify missing or over defined contact regions
• Use it to document contact definition
• Use it in combination with the filtering and tagging capabilities to more easily parse through a large assembly model

Summary of steps to enable the Body Views feature:

• Click on the Connections Branch in the Model Tree so that the Connections context toolbar appears

• Click Body Views
• Select your desired contact region to analyze

• Use the two views to evaluate

• Use the Sync Views option to force views to move together

To my chagrin, this option has been available in ANSYS for a few releases at least and I never took note. But the possibility that some of you might have also overlooked this option prompted me to highlight it for you and I hope you find it useful in the future.

### Final thought:

If you found this article helpful and are interested in learning about or being reminded of some other excellent ANSYS time saver capabilities, check out the article by Eric Miller on filtering and tagging here.

## Checking Hyper-Elastic Material Models

When using hyper-elastic materials, analyst often have little material data to assist them. Fortunate engineers will have a tensile stress-strain curve; a lucky few will also have a simple shear stress-strain curve as well. Where do you start?

To gain confidence in the procedure which is typically used, a set of FEA models were run in a closed loop. The loop consists of assuming some material parameters, running FEA models based upon those parameters, and then using the FEA results to recover the material parameters using ANSYS’s built in hyper-elastic curve fitting.

To isolate the material model from boundary conditions effects, simple FEA models that are 3D but have 1D stress states are used. The figures below show tensile and shear models that can be used to verify material models.

For this article, a 2 Parameter Mooney-Rivlin material model with values consistent with typical Imperial units was selected. The figure below shows the data entry including a value of zero for d which indicates that the material is fully incompressible.

The tensile test FEA model was run with this 2 parameter MR model. The engineering stress-strain results were extracted from the results using /post26 APDL. The results are graphed and listed in the figure below. We use APDL because there are some calculations involved with getting engineering results. For example, the engineering stress was calculated by dividing the reaction force at node n1 by the original area like this:

`RFORCE,2,n1,F,z,Fz_2QUOT,3,2, , , , , ,-1/area_,1,`

This test data was then used in ANSYS’s curve fitting routine. The results of the curve fitting are shown below. The parameters from the curve fitting results are < 0.01% different than the assumed inputs. This is a reassuring result. Note that this is one instance in ANSYS that you are required to use engineering data (for hyper-elastic curve fitting only).

In recent versions of ANSYS, a hyper-elastic response function was introduced. This allows the user to enter the test data and use it without curve fitting. The figure below shows how uniaxial tension test data is entered and the response function activated to use it.

As expected, the response function matched the /post26 output exactly. This method offers a clear advantage in that the user doesn’t need to assume a material model.

The next step in this verification process was to run some simple shear FEA models to compare the curve fitting results. The plot below shows the engineering shear stress-strain curve using the 2 parameter MR model from above.

The data was curve fitted as shown in the figure below. This time both the uniaxial tension and simple shear data are entered. The resulting 2 parameter model differs (<2%) from the entered model.

These new values were used in the FEA models. As shown in the figures below, the change in material parameters (<2%) did not significantly change the tensile or shear stress-strain results (<1%). This raises some interesting questions regarding the 2 parameter MR model that will be explored at a later date.

## You will be Surprised Where Sneeze Germs Travel in an Airplane

Ever been on a flight, hear someone sneeze, and then sit in fear as you imagine millions of tiny infectiousness germs laughing historically as they spread through the cabin of the plane?  In my imagination they are green and drip mucus. In reality they are small liquid particles and instead of going everywhere, it appears they fall on just a few unlucky people.

ANSYS, Inc.  put out a very cool video showing the results of an in-cabin CFD run done by Purdue University that tracks the pathogens as they leave the sick persons mouth, get caught in the climate control system’s air stream, and waft right on the people next to and behind them.  The study was done for the FAA Center for Excellence for Airliner Cabin Environment Research.

Here is the video, check it out and share with your friends. Especially if you have a friend that doesn’t sneezes out into the open air:

Visit the ANSYS Blog to learn even more.

#betterlivingthroughsimulation

## A Little Project Background

Recently I’ve been working on developing a computer vision system for a long standing customer. We are developing software that enables them to use computers to “see” where a particular object is space, and accurately determine its precise location with respect to the camera. From that information, they can do all kinds of useful things.

In order to figure out where something is in 3D space from a 2D image you have to perform what is commonly referred to as pose estimation. It’s a highly interesting problem by itself, but it’s not something I want to focus on in detail here. If you are interested in obtaining more information, you can Google pose estimation or PnP problems. There are, however, a couple of aspects of that problem that do pertain to this blog article. First, pose estimation is typically a nonlinear, iterative process. (Not all algorithms are iterative, but the ones I’m using are.) Second, like any algorithm, its output is dependent upon its input; namely, the accuracy of its pose estimate is dependent upon the accuracy of the upstream image processing techniques. Whatever error happens upstream of this algorithm typically gets magnified as the algorithm processes the input.

## The Problem I Wish to Solve

You might be wondering where we are going with HPC given all this talk about computer vision. It’s true that computer vision, especially image processing, is computationally intensive, but I’m not going to focus on that aspect. The problem I wanted to solve was this: Is there a particular kind of pattern that I can use as a target for the vision system such that the pose estimation is less sensitive to the input noise? In order to quantify “less sensitive” I needed to do some statistics. Statistics is almost-math, but just a hair shy. You can translate that statement as: My brain neither likes nor speaks statistics… (The probability of me not understanding statistical jargon is statistically significant. I took a p-test in a cup to figure that out…) At any rate, one thing that ALL statistics requires is a data set. A big data set. Making big data sets sounds like an HPC problem, and hence it was time to roll my own HPC.

## The Toolbox and the Solution

My problem reduced down to a classic Monte Carlo type simulation. This particular type of problem maps very nicely onto a parallel processing paradigm known as Map-Reduce. The concept is shown below:

The idea is pretty simple. You break the problem into chunks and you “Map” those chunks onto available processors. The processors do some work and then you “Reduce” the solution from each chunk into a single answer. This algorithm is recursive. That is, any single “Chunk” can itself become a new blue “Problem” that can be subdivided. As you can see, you can get explosive parallelism.

Now, there are tools that exist for this kind of thing. Hadoop is one such tool. I’m sure it is vastly superior to what I ended up using and implementing. However, I didn’t want to invest at this time in learning a specialized tool for this particular problem. I wanted to investigate a lower level tool on which this type of solution can be built. The tool I chose was node.js (www.nodejs.org).

I’m finding Node to be an awesome tool for hooking computers together in new and novel ways. It acts kind of like the post office in that you can send letters and messages and get letters and messages all while going about your normal day. It handles all of the coordinating and transporting. It basically sends out a helpful postman who taps you on the shoulder and says, “Hey, here’s a letter”. You are expected to do something (quickly) and maybe send back a letter to the original sender or someone else. More specifically, node turns everything that a computer can do into a “tap on the shoulder”, or an event. Things like: “Hey, go read this file for me.”, turns into, “OK. I’m happy to do that. I tell you what, I’ll tap you on the shoulder when I’m done. No need to wait for me.” So, now, instead of twiddling your thumbs while the computer spins up the harddrive, finds the file and reads it, you get to go do something else you need to do. As you can imagine, this is a really awesome way of doing things when stuff like network latency, hard drives spinning and little child processes that are doing useful work are all chewing up valuable time. Time that you could be using getting someone else started on some useful work. Also, like all children, these little helpful child processes that are doing real work never seem to take the same time to do the same task twice. However, simply being notified when they are done allows the coordinator to move on to other children. Think of a teacher in a class room. Everyone is doing work, but not at the same pace. Imagine if the teacher could only focus on one child at a time until that child fully finished. Nothing would ever get done!

Here is a little graph of our internal cluster at PADT cranking away on my Monte Carlo simulation.

It’s probably impossible to read the axes, but that’s 1200+ cores cranking away. Now, here is the real kicker. All of the machines have an instance of node running on them, but one machine is coordinating the whole thing. The CPU on the master node barely nudges above idle. That is, this computer can manage and distribute all this work by barely lifting a finger.

## Conclusion

There are a couple of things I want to draw your attention to as I wrap this up.

1. CUBE systems aren’t only useful for CAE simulation HPC! They can be used for a wide range of HPC needs.
2. PADT has a great deal of experience in software development both within the CAE ecosystem and outside of this ecosystem. This is one of the more enjoyable aspects of my job in particular.
3. Learning new things is a blast and can have benefit in other aspects of life. Thinking about how to structure a problem as a series of events rather than a sequential series of steps has been very enlightening. In more ways than one, it is also why this blog article exists. My Monte Carlo simulator is running right now. I’m waiting on it to finish. My natural tendency is to busy wait. That is, spin brain cycles watching the CPU graph or the status counter tick down. However, in the time I’ve taken to write this article, my simulator has proceeded in parallel to my effort by eight steps. Each step represents generating and reducing a sample of 500,000,000 pose estimates! That is over 4 billion pose estimates in a little under an hour. I’ve managed to write 1,167 words…

## Continue a Workbench Analysis in ANSYS MAPDL R15

This article outlines the steps required to continue a partially solved Workbench based analysis using a Multi-Frame Restart and the MAPDL Batch mode.

• Some ways to interface between ANSYS Workbench and ANSYS MAPDL
• How to re-launch a run using a Multi-Frame Restart in ANSYS Batch mode
• The value of the jobname.abt functionality for Static Structural and Transient Structural analyses

Recently I was working in the ANSYS Workbench interface within the Mechanical application running a Transient Structural analysis. I began my run thinking that my workstation had the necessary resources to complete the analysis in a reasonable amount of time. As the analysis slowly progressed, I began to realize that I needed to make a change and switch to a computer that had more resources. But some of my analysis was already complete and I did not want to lose that progress. In addition, I wanted to be sure that I could monitor the analysis intermediately to ensure that it was advancing as I would like. This meant that however I decided to proceed I needed to make sure that I could still read my results back into Mechanical along with having the capability to restart again from a later point. Here were my options.

1: I could use the Remote Solve Manager (RSM) to continue running my analysis on a compute server machine. Check out this article for more on that.

I did use RSM in part but perhaps you do not have RSM configured or your computer resources are not connected through a network. Then I will show the other option you can use.

2: A Multi-Frame Restart using MADPL in ANSYS Batch mode

Here’s the process:

1. Make note of the current load step and last converged substep that your analysis completed when you hit the Interrupt Solution button

2. Copy the *.rdb, *.ldhi, *.Rnnn files from the Solver Files Directory on the local machine to the Working Directory on the computing machine

You can find your Solver Files Directory by right clicking on the Solution Branch in the Model Tree and selecting Open Solver Files Directory:

3. Write an MAPDL input file with the commands to launch a restart and save it in the Working Directory on the computing machine (save with extension *.inp)

Below is an example of an input that will work well for restarting an analysis, but feel free to adjust it with the understanding that the ANSYS Programming Design Language (APDL) is a sophisticated language with a vast array of capability.

4. Start the MADPL Product Launcher interface on the computing machine and:
a: Set Simulation Environment to ANSYS Batch
b. Navigate to your Working Directory
c. Set the jobname to the same name as that of the *.rdb file
d. Browse to the input file you generated in Step 3
e. Give your output file a descriptive name
f. Adjust parallel processing and memory settings as desired
g. Run

5. Look at the output file to see progress and monitor the run

6. Write “nonlinear” in a text file and save it as jobname.abt inside the Working Directory to cleanly interrupt the run and generate restart files when desired

The jobname.abt will appear briefly in the Working Directory

The output file will read the following:

Note that the jobname.abt interruption process is the exact process that ANSYS uses in the background when the Interrupt Solution button is pressed interactively in Mechanical

7. Copy all newly created files in Working Directory on the computing machine to the Solver Files Directory on the local machine

8. Back in the Mechanical application, highlight the Solution branch of the model tree, select Tools menu>Read Results Files… and navigate to the Solver Files Directory and read the updated *.rst file

After you have read in the results file, notice that the restart file generated from the interruption through the jobname.abt process appears as an option within the Mechanical interface under Analysis Settings

9. Review intermediate results to determine if analysis should continue or if adjustments need to be made

10. Repeat entire process to continue analysis using the new current loadstep and substep

Happy solving!

Here are some useful Help Documentation sections in ANSYS 15 for your reference:

• Understanding Solving:
• help/wb_sim/ds_Solving.html
• Mechanical APDL: Multiframe Restart:
• help/ans_bas/Hlp_G_BAS3_12.html#BASmultrestmap52199

## Video Tips: Create and Display Custom Units in ANSYS CFD-Post

By: Susanna Young

ANSYS CFD-Post is a powerful tool capable of post-processing results from multiple ANSYS tools including FLUENT, CFX, and Icepak. There are almost endless customizable options in ANSYS CFD-Post. This is a short video demonstrating how to create and display a set of custom units within the tool. Stay tuned for additional videos on tips for more effective post-processing in ANSYS CFD-Post.

## ANSYS Remote Solve Manager (RSM): Answers to Some Frequently Asked Questions

For you readers out there that use the ANSYS Remote Solve Manager (RSM) and have had one or all of the below questions, this post might just be for you!

1. What actually happens after I submit my job to RSM?
2. Where are the files needed to run the solve go?
3. How do the files get returned to the client machine, or do they?
4. What if something goes wrong with my solve or in the RSM file downloading process, is there any hope of recovery?
5. Are there any recommendations out there for how best to use RSM?

If your question is, how do I setup RSM as a user? You answers are here from a post by Ted Harris. The post today is a deeper dive into RSM.

The answers to questions 1 through 3 above are really only necessary if you would like to know the answer to question 4. My reason for giving you a greater understanding of the RSM process is so that you can do a better job of troubleshooting should your RSM job run into an issue.  Also, please note that this process is specifically for an RSM job submitted for ANSYS Mechanical. I have not tested this yet for a fluid flow run.

## What happens when a job gets submitted to RSM?

The following will answer questions 1-3 above.

When a job is run locally (on your machine), ANSYS uses the Solver Files Directory to store and update data. That folder can be found by right clicking on the Solution branch in the Model tree and selecting Open Solver Files Directory.

The project directory will be opened and you can see all of the existing files stored for your particular solution:

When a job gets submitted to RSM, the files that are stored in the above folder will be transferred to a series of two temporary directories. One temporary directory on the client side (where you launched the job from) and one temporary directory on the compute server side (where the numbers get crunched).

After you hit solve for a remote solve, you will notice that your project solver directory gets emptied. Those files are transferred to a temporary directory under the _ProjectScratch directory:

Next, these files get transferred to a temporary directory on the compute server. The files in the _ProjectScratch directory will remain there but the folder will not be updated again until the solve is interrupted or finished.

You can find the location of the compute server temporary directory by looking at the output log in the RSM queueing interface:

If you navigate to that directory on your compute server, you will see all of the necessary files needed to run. Depending on your IT structure, you may or may not have access to this directory, but it is there.

Here is a graphical overview of the route that your files will experience during the RSM solve process.

Once your run is completed or you have interrupted it to review intermediate results and your results have been downloaded and transferred to the solver files folder, both of the temporary directories get cleaned up and removed. I have just outlined the basic process that goes on behind the scenes when you have submitted a job to RSM.

## What if something goes wrong with my RSM job? Can I recover my data and re-read it into Workbench?

Recently, I ran into a problem with one of my RSM jobs that resulted in me losing all of the data that had been generated during a two day run. The exact cause of this problem I haven’t determined but it did force me to dive into the RSM process and discover what I am sharing with you today. By pin-pointing and understanding what goes on after the job is submitted to RSM, I did determine that it can be possible to recover data, but only under certain circumstances and setup.

First, if you have the “Delete Job Files in Working Directory” box checked in the compute server properties menu accessed from the RSM queue interface (see below) and RSM sees your job as being completed, the answer to the above question is no, you will not be able to recover your data. Essentially, because the compute server is cleaned up and the temporary directory gets deleted, the files are lost.

To avoid lost data and prepare for such a catastrophe, my recommendation is that you or your IT department, uncheck the “Delete Job Files in Working Directory” box. That way, you have a backup copy of your files stored on the server that you can delete later when you are sure you have all of your files safely transferred to your solver files folder within your project directory structure.

The downside to having this box unchecked is that you have to manually cleanup your server. Your IT department might not like, or even allow you to do this because it could clutter your server if you do not stay on top of things. But, it could be worth the safety net.

As for getting your data back into Workbench, you will need to manually copy the files on the compute server to your solver files folder in your Workbench project directory structure. I explained how to access this folder at the beginning of this post. Once you have copied those files, back in the Mechanical application, with the Solution branch of your model tree highlighted, selects Tools>Read Results Files… (see below graphic), navigate to your solver files directory, select the *.rst file and read it in.

Once the results file is read in, you should see whatever information is available.

## Recommendations

• Though it is possible to run concurrent RSM jobs from the same project, my recommendation is to only run one RSM job at a time from the same project in order to avoid communication or licensing holdups

• Unless you are confident that you will not ever need to recover files, consider unchecking the “Delete Job Files in Working Directory” box in the compute server properties menu.

• Note: if you are not allowed access to your compute server temporary directories, you should probably consult your IT department to get approval for this action.

• Caution: if you uncheck this box, be sure that you stay on top cleaning up your compute server once you have your files successfully downloaded

• Depending on your network speed, when your results files get large, >15GB, be prepared to wait for upload and download times. There is likely activity, but you might not be able to “see” it in the progress information on the RSM output feed. Be patient or work outside of RSM using a batch MAPDL process.

• Avoid hitting the “Interrupt Solution” command more than once. I have not verified this, but I believe this can cause mis-communication between the compute server and local machine temporary directories which can cause RSM to think that there are no files associated with your run to be transferred.