Sometimes you just get tired of clicking on icons.  Sometimes you just need to feel the control and power of launching your applications from the command line.  You type it in, you hit the enter key, and sometimes you can actually hear the disk spin up or the fan run faster to cool the processor as the program you asked for, the program you took time to type out, leaps to life in front of you. Satisfaction.

OK, maybe not.  More often you are scripting some batch solves.  Or maybe you are using the graphical user interface in Workbench but you need to set options for the solvers you are running from within workbench.  Because most of the solvers in the ANSYS family of products predate such new-fangled concepts as GUI’s, and because they are often run remotely on other machines, they have command line interfaces. And that gives the knowledgeable user more power and control.

General Concepts for Launching from the Command Line

Although the number of options available changes from application to applications, there a few common things you should know. 

Paths

The first and most important concept is to be aware of the path.  This is where most errors happen. One of the big changes over the years is that as software gets more complicated, the executable program or script that you use to launch a solver is now buried deep down inside a directory structure.  Since we never run in that actual directory we need to tell the operating system where the executable is. You can do this by including the full directory path in your command line argument, or by adding it to your path. 

On Linux follow the directions in the help:

// Installation and Licensing Documentation // Linux Installation Guide // 5. Post-Installation Instructions

for each of the products you want to run. Generally, you need to set the PATH environmental variable in your .cshrc, .login, or .profile. 

On Windows it is not documented, the assumption being that you will be clicking on icons and not typing into a command window.  So a little detective work is needed. Use a file explorer and the Linux documentation on launching to locate the executable for solvers you want to use:

// Installation and Licensing Documentation // Linux Installation Guide // 5. Post-Installation Instructions // 5.3. Launching ANSYS, Inc. Products

The /ansys_inc part is usually replaced with c:\Program Files\ANSYS Inc.  The rest of the path is pretty much the same, swapping forward slashes with backward slashes.  Use these paths in your command line or add to your path by:

From the desktop, right-click My Computer and click Properties.

In the System Properties window, click on the Advanced tab.

In the Advanced section, click the Environment Variables button.

Finally, in the Environment Variables window (as shown below), highlight the Path variable in the Systems Variable section and click the Edit button. Add or modify the path lines with the paths you wish the computer to access. Each different directory is separated with a semicolon as shown below.

Important note for Windows:  If you are typing the path in on the command line, you need to put it in double quotes.  The convention on Windows is to specify directories with spaces in the name.  But the convention is not to have a command line parser that recognizes this.  So you will get an error if you type:

C:\Program Files\ANSYS Inc\v140\ansys\bin\winx64\ansys140.exe

But if you put it in quotes, it works fine:

"C:\Program Files\ANSYS Inc\v140\ansys\bin\winx64\ansys140.exe"

Versions Numbering

If you look at the example for launching MAPDL above you will notice that 140 is used in the directory path and in the name of the executable.  This will change with version:  v130, v145, etc…  Just be aware of that if you are reading this blog posting in 3 years and we are on release 16.5.  you would use:

"C:\Program Files\ANSYS Inc\v165\ansys\bin\winx64\ansys165.exe"

Where do you Launch From?

You of course need a command line to launch a solver.  This is usually a window that lets you type operating system commands: called a Command Prompt in Windows or a shell on Linux.  On Linux it can be an xterm window, a console window, or some other terminal window you have opened. 

But you can also launch from a script, and that script can be launched from a command prompt or shell, or it can be launched by an icon.  All that needs to happen is that the script needs to be executed with the environmental variables required for the command prompt/script or the GUI.  If you don’t know how to make that happen, contact your IT support or someone who understands your operating system and how it runs processes.

ANSYS Mechanical APDL

The solver with the most options and capabilities from the command line is Mechanical APDL. So we will start there.  It is important to know these even if you use Mechanical most of the time.  That is because you can set these, and better control your solves, under Tools->Options->Mechanical APDL.  Here is what that dialog looks like:

The most common settings have their own widgets,  and the others can all be accessed by using “- string” command line style arguments in the first text widget aptly named: Command Line Options.

Here are the options, grouped for your studying pleasure:

Option	Type	Description
-ansexe	Customization	In the ANSYS Workbench environment, activates a custom ANSYS executable.
-custom	Customization	Calls a custom ANSYS executable. See help on running custom executables for more
-acc device	HPC	Enables the use of GPU compute accelerator. As this is written, nvidia is the only option. But as other cards become available look for this to have other options. Check the help.
-dis	HPC	Enables Distributed ANSYS. See the Parallel Processing Guide for more information.
-machines	HPC	Specifies the machines on which to run a Distributed ANSYS analysis. See Starting Distributed ANSYS in the Parallel Processing Guide for more information.
-mpi	HPC	Specifies the type of MPI to use. See the Parallel Processing Guide for more information.
-mpifile	HPC	Specifies an existing MPI file (appfile) to be used in a Distributed ANSYS run. See Using MPI appfiles in the Parallel Processing Guide for more information.
-np value	HPC	Specifies the number of processors to use when running Distributed ANSYS or Shared-memory ANSYS.
-d device	Interface	Specifies the type of graphics device. This option applies only to interactive mode. For Linux systems, graphics device choices are X11, X11C, or 3D. For Windows systems, graphics device options are WIN32 or WIN32C, or 3D.
-g	Interface	Launches the ANSYS program with the Graphical User Interface (GUI) on. Linux only. On windows do a /SHOW and /MENU,ON to get the GUI up.
-l language	Interface	Specifies a language file to use other than US English.
-b [list | nolist]	Launch	Activates the ANSYS program in batch mode. The options -b list or -b by itself cause the input listing to be included in the output. The -b nolist option causes the input listing not to be included
-i inputname	Launch	Specifies the name of the file to read input into ANSYS for batch processing. On Linux, the preferred method to indicate an input file is <. Requried with -b option.
-j Jobname	Launch	Specifies the initial jobname, a name assigned to all files generated by the program for a specific model. If you omit the -j option, the jobname is assumed to be file.
-o outputname	Launch	Specifies the name of the file to store the output from a batch execution of ANSYS. On Linux, the preferred method to indicate an output file is >.
-p productname	Launch	Defines which ANSYS product will run during the session (ANSYS Multiphysics, ANSYS Structural, etc.). This is how you pull a different licence from the default. Very handing if you have multiple licenses to choose from.
-s [read | noread]	Launch	Specifies whether the program reads the start140.ans file at start-up. If you omit the -s option, ANSYS reads the start140.ans file in interactive mode and not in batch mode.
-dir	Luanch	Defines the initial working directory. Remember to use double quotes if you have spaces in your directory path name. Using the -dir option overrides the ANSYS140_WORKING_DIRECTORY environment variable.
-db value	Memory	Defines the portion of workspace (memory) to be used as the initial allocation for the database. This and -m are the two most important options. If you ever find that ANSYS is writing a *.PAGE file, up this number.
-m value	Memory	Idefines the total memory to reserve for the program. It is always better to reserve it up front rather than letting ANSYS grab as it needs.
-schost host name	MFX	Specifies the host machine on which the coupling service is running (to which the co-simulation participant/solver must connect) in a System Coupling analysis.
-scname name of the solver	MFX	Specifies the unique name used by the co-simulation participant to identify itself to the coupling service in a System Coupling analysis. For Linux systems, you need to escape the quotes or escape the space to have the name recognized with a space:
-scport port number	MFX	Specifies the port on the host machine upon which the coupling service is listening for connections from co-simulation participants in a System Coupling analysis.
-mfm	MFX	Specifies the master field name in an ANSYS Multi-field solver - MFX analysis. See Starting and Stopping an MFX Analysis in the Coupled-Field Analysis Guide for more information.
-ser value	MFX	Specifies the communication port number between ANSYS and CFX in an MFX analysis.
-dvt	Other	Enables ANSYS DesignXplorer advanced task (add-on).
-dyn	Other	Enables LS-DYNA.
-v	Other	Returns the ANSYS release number, update number, copyright date, customer number, and license manager version number. Does not actually run ANSYS MAPDL.
-name value	Params	Defines ANSYS parameters at program start-up. The parameter name must be at least two characters long. These get passed into ANSYS and are used by any APDL scripts you run.

The ones that everyone should know about are: –p, –m, –db.  We find that not using these to define what license to use (-p) or to control how memory is pre-allocated (-m, –db) generate the most tech support questions.    The next most important is the –np command. Use this to define more processors if you have HPC licenses.

Cheating – Use the Launcher

Sometimes the options can get long and confusing.  So what I do is I use the “ANSYS Mechanical APDL Launcher” and fill in all the forms. then go to tools->View Display Command Line and I can see all the options.

Here is a a fancy command line that got generated that way:

"C:\Program Files\ANSYS Inc\v140\ANSYS\bin\winx64\ansys140.exe"  -g -p ane3flds -np 2 -acc nvidia -dir "c:\temp" -j "grgewrt1" -s read -m 5000 -db 1000 -l en-us -lstp1 32 -t -d win32 -custom "/temp/myansys.exe"  

It runs interactive (-g), uses a multiphysics license (-p ane3flds), grabs two processors (-np 2), uses an NVIDEA GPU (-acc nvidia (I don’t have one…)), runs in my temp directory (-dir), uses a job name of grgewrt1 (-j), reads the start.ans file (-s), grabs 5000mb and 1000mb for memory (-m, –db), uses English, passes in a parameter called lstp1 and sets it to 32 (-), uses the win32 graphics driver (-d) and runs my custom ANSYS executable (-custom).

I have no idea what –t is.  Some undocumented option I guess…

ANSYS Workbench

ANSYS Workbench also has some command line arguments. not as rich as what is available in MAPDL, but still powerful. It allows you to run Mechanical in Batch or Interactive mode, supply python commands as needed.  The key thing to remember is that the workbench interface is not Mechanical or FLUENT. It is the infrastructure that other programs run on. Scripting in workbench allows you to control material properties, parameters, and how systems are created and executed.

Here are the options:

Argument	Operation
-B	Run ANSYS Workbench in batch mode. In this mode, the user interface is not displayed and a console window is opened. The functionality of the console window is the same as the ANSYS Workbench Command Window.
-R <ANSYS Workbench script file>	Replay the specified ANSYS Workbench script file on start-up. If specified in conjunction with –B, ANSYS Workbench will start in batch mode, execute the specified script, and shut down at the completion of script execution.
-I	Run ANSYS Workbench in interactive mode. This is typically the default, but if specified in conjunction with –B, both the user interface and console window are opened.
-X	Run ANSYS Workbench interactively and then exit upon completion of script execution. Typically used in conjunction with –R.
-F <ANSYS Workbench project file>	Load the specified ANSYS Workbench project file on start-up.
-E <command>	Execute the specified ANSYS Workbench scripting command on start-up. You can issue multiple commands, separated with a semicolon (;), or specify this argument multiple times and the commands will be executed in order.

The big deal in this list is the –B argument.  This allows you to run workbench, and applications controlled by the project page, in batch mode.  You will usually use the –R argument to specify the Iron Python script you want to run.  In most cases you will often want to throw in a –X to make sure it exists when the script is done. 

Other ANSYS Products

Here is where it gets boring.  The other products just don’t have all those options. At least not documented.  So you simply find the executable and run it.  Here is the list for Linux. Use it to find the location on Windows.

Product	Command
Mechanical APDL	/ansys_inc/v140/ansys/bin/ansys140
ANSYS Workbench	/ansys_inc/v140/Framework/bin/<platform>/runwb2
ANSYS CFX	/ansys_inc/v140/CFX/bin/cfx5
ANSYS FLUENT	/ansys_inc/v140/fluent/bin/fluent
ANSYS ICEM CFD	/ansys_inc/v140/icemcfd/<platform>/bin/icemcfd
ANSYS POLYFLOW	/ansys_inc/v140/polyflow/bin/polyman
ANSYS CFD-Post	/ansys_inc/v140/CFD-Post/bin/cfdpost
ANSYS Icepak	/ansys_inc/v140/Icepak/bin/icepak
ANSYS TurboGrid	/ansys_inc/v140/TurboGrid/bin/cfxtg
ANSYS AUTODYN	/ansys_inc/v140/autodyn/bin/autodyn140

APDL Math.  It is one of the most powerful, uber-user, deep down under the hood, wrapping your hands around the neck of what FEA is, capabilities in the ANSYS Mechanical APDL (MAPDL) solver.  And most users don’t even know it is there.  It kind of snuck in over time, with the developers adding more and more capability each release.  Now it gives you access that you needed custom FORTRAN code to get to in the past… or NASTRAN DMAP, which is really something none of us ever want to do.

There is a lot of capability in this tool. This posting is just going to cover the basics so that you know what the tool can be used for in case you need it in the future, and hopefully motivate some of you to take a long look at the help. 

What is APDL Math?

It is an extension to the APDL command language that drives MAPDL.   Although it runs in a different workspace (chunk of memory in the ANSYS database) it talks to standard APDL by importing and exporting APLD arrays (vectors or matrices).  It consists, at R14, of 18 commands that can be executed at the /SOLU level at any time.  All of the commands start with a * character and look and act like standard APDL commands.

APDL Math is a tool for users to do two things: 1) get access to view, export or modify matrices and vectors created by the solver, and 2) to control import or modify matrices and vectors then solve them.  The most common uses we have seen is the exporting of a matrix from ANSYS for use in some other program, usually Matlab.  The other is working with sub-structure matrices.

The entire tool is documented in the Mechanical APDL section of the help under  // ANSYS Parametric Design Language Guide // 4. APDL Math.

The Commands

Below is a list of the APDL math commands.  As usual, you really need to read the manual entries to get the full functionality explained.  Just like parameters and arrays in APDL, the matrices and vectors in APDL Math use names to identify them.  Note that you have a set of commands to create the matrix/vector you want, which includes reading from a file or importing an APDL array.  then you have commands to do basic matrix/vector math like multiply, find dot products, and do Fast Fourier Transformations.  Then there are solver commands.

Commands to create and delete matrices and vectors

*DMAT, Matrix, Type, Method, Val1, Val2, Val3, Val4, Val5

Creates a dense matrix that is complex, double or integer. You can allocate it, resize an existing matrix, copy a matrix, or link to a portion of a matrix. You can also import from a file or an APDL variable.

*SMAT, Matrix, Type, Method, Val1, Val2, Val3

Creates a sparse matrix. Double or Complex, copied or imported.

*VEC, Vector, Type, Method, Val1, Val2, Val3, Val4

Creates a vector. Double, complex or integer. Similar arguments to *DMAT.

*FREE, Name,

Deletes a matrix or a solver object and frees its memory allocation. Important to remember to do.

Commands to manipulate matrices

*AXPY, vr, vi, M1, wr, wi, M2

Performs the matrix operation M2= v*M1 + w*M2.

*DOT, Vector1, Vector2, Par_Real, Par_Imag

Computes the dot (or inner) product of two vectors.

*FFT, Type, InputData, OutputData, DIM1, DIM2, ResultFormat

Computes the fast Fourier transformation of the specified matrix or vector.

*INIT, Name, Method, Val1, Val2, Val3

Initializes a vector or dense matrix. Used to fill vectors or matrices with zero's, constant values, random values, or values on the diaganol.

*MULT, M1, T1, M2, T2, M3

Performs the matrix multiplication M3 = M1(T1)*M2(T2).

*NRM, Name, NormType, ParR, Normalize

Computes the norm of the specified vector or matrix.

*COMP, Matrix, Algorithm, Threshold

Compresses the columns of a matrix using a specified Singular value decomposition algorithm (default) or Modified Gram-Schmidt algorithm

Commands to perform solutions

*LSENGINE, Type, EngineName, Matrix, Option

Creates a linear solver engine and assignes a name to be used when you want to execute the solve. Does Boeing sparse, MKL sparse, LAPACK or Distributed Sparse.

*LSFACTOR, EngineName, Option

Performs the numerical factorization of a linear solver system.

*LSBAC, EngineName, RhsVector, SolVector

Performs the solve (forward/backward substitution) of a factorized linear system.

*ITENGINE, Type, EngineName, PrecondName, Matrix, RhsVector, SolVector, MaxIter, Toler

Performs a solution using an iterative solver.

*EIGEN, Kmatrix, Mmatrix, Cmatrix, Evals, Evects

Performs a modal solution with unsymmetric or damping matrices.

Commands to output matrices

*EXPORT, Matrix, Format, Fname, Val1, Val2, Val3

Exports a matrix to a file in the specified format. Supports Matrix Market, ANSYS SUB, DMIG, Harwell-Boeing and ANSYS EMAT. Also used to put values in an APDL array or print in a formated way to a postscript file.

*PRINT, Matrix, Fname

Prints the non-zero matrix values to a text file.

Useful APDL Commands

/CLEAR, Read

Wipes all APDL and APDL Math values from memory

WRFULL, Ldstep

Stops solution after assembling global matrices. Use this to make matrices you need when you don't want a full solve

/SYS, String

Executes an operating system command. This can be used in APDL Math to do some sort of an external operation on a matrix you wrote out to a file, like running a matlab script. After execution the matrix can be read back in and used.

 

How You Use APDL Math

When using APDL math you should follow some basic steps.  I’m always a big proponent of the crawl-walk-run approach to anything, so I also recommend that you start with small, simple models to figure stuff out.

First Step: Know the Math

The first step, or maybe the zero’th, is to understand your math.  If you charge in and start grabbing the stiffness matrix from the .FULL file and changing values, who knows what you will end up with. Chart out the math you want to do on paper or in a tool like Mathematica. 

Then makes sure that you understand the math in ANSYS, and that includes the files being used by ANSYS.  A good place to look is in the Programmer’s Manual, Chapter 1 lists the various files and what is in them.  It might also not be a bad idea for you to crack open the theory manual  We all know that ANSYS solve Kx = F, but how, and what matrices and vectors are used.  Section 17.1 explains the static analysis approach used, with lots of links to more detailed explanations.

Second Step: Create your Matrices/Vectors

Since the whole point of using APDL math is to do stuff with Matrices/Vectors, you need to start by creating them.  Note that we are not doing anything with APDL Math yet.  We are using APDL, ANSYS, or an external program to get our matrix/vector so that we can then get it into APDL Math.. There are three types of sources you can get matrices/vectors from:

1. Use APDL to create an array.  *DIM, *SET, *VREAD, *MOPER, etc… 
2. Use ANSYS to make them as part of a solve, or as part of an “almost solve” using WRFULL.  You can read the .FULL, .EMAT, .SUB, .MODE or .RST
3. Get a file from some other source and put it into a format that APDL Math can read. It supports Harwell-Boeing, Matrix Market, or NASTRAN DMIG format as well as APDL Math’s own format.

Third Step: Get the Matrices/Vectors into APDL Math

Using *DMAT, *SMAT, and *VEC you convert the APDL array, ANSYS file, or external format file into a matrix or a vector.  You can also use *INIT to make one from scratch, filling it with constants, zeros, random numbers or by setting the diagonal or anti-diagonal  values.

Fourth Step: Manipulate the Matrices/Vectors

In this step you can modify matrices in a lot of different ways.  The simplest is to use *MULT or *AXPY to do math with several matrices/vectors to get a new matrix/vector. 

Another simple way to change things is to simply refer to the entries in the matrix using APDL.  As an example, to change the damping at I=4 and J =5 in a damping matrix called dmpmtrx just use dmpmtrx(4,5) – 124.321e4.

You can take that one step further and use the APDL operators that work on arrays like *SET, *MOPER, *VGUN and whatever *DO loops you need. 

If you can’t do the modification you need in APDL or APDL Math, then you can use *EXPORT to write the matrices out and use an external tool like matlab or Mathematica to do your manipulation. Of course you then use *DMAT with an IMPORT argument to read the modified matrix/vector back inside.

Fifth Step: Use the Matrix

Now it is finally time to use your matrices/vectors.  The most common use is to bundle it up in a substructure matrix (*EXPORT,,SUB) and use it in a solve.  What is great about this is that you can also (I know, we don’t want to use the N-word) save the file as a NASTRAN substructure and give it to that annoying DMAP guru who insists that NASTRAN is the only structural analysis code in the world.  He gets his file, and you get to use ANSYS.

You can also solve using APDL Math.  This can require multiple steps depending on what you want to do. A typical solve involves using the *LSENGINE command to define how you want to solve, then factor your matrix with *LSFACTOR, then solve with *LSBAK.

There are also ways to continue a solve in ANSYS after changing the EMAT file.  Unfortunately my plans to do an example of this have been thwarted and ANSYS did not provide one, so I’m not 100% sure on the steps required.  But a LSSOLVE that does not force ANSYS to recreate the matrices should work.  Maybe a topic for a future posting. 

Other Stuff to Know About

There is a lot more too this, and the help is where you can learn more.  But a few things everyone needs to be ware of are listed here.

DOF Order

A key area where people have problems is understanding how the DOF’s in your matrix or vector are ordered. This is because ANSYS reorders things for efficiency of memory and solve.  The nice thing is that ANSYS stores a map in the full file that you can use to convert back and forth using the *MULT command. 

Please read section 4.4 ( // ANSYS Parametric Design Language Guide // 4. APDL Math // 4.4. Degree of Freedom Ordering) in the manual. They have a great description and some examples.

Just remember to remember to deal with DOF ordering.

Limitations

This is still a new tool set and as users apply it to real world problems, they are adding functionality.  Right now there are some limitations. 

• The biggest is that that all of this works on linear matrices.  So you have to be working on a linear problem. Material or geometric non-linarites just don’t work.  This makes perfect sense but may be one of those things some users might not figure out till they have invested some serious time.
• You can not modify a sparse matrix in APDL Math.  You have to write it out using *EXPORT, modify it with something like matlab, then read it back in with *SMAT.
• *MULT can not be used to multiply two sparse matrices. One or both must be dense.  the result is always dense.
• The BCS, DSS and DSP solves only work with sparse matrices. Only the LAPACK solver works for a dense matrix.

Real and Imaginary

Most of the features in APDL math work with matrices that have imaginary terms in them. Be careful and read the help if you are using complex math, it can get tricky.  Especially read 4.3 on how to specify a position in a matrix for real or imaginary numbers.

Examples

There are not a lot out there.  The manual has some in section 4.7.  Take a look at these before you do anything. If you can not find a specific example, contact your technical support provider and see if they have one, or if they can ask development for one.

Give it a Shot, and Share

This is a new feature, and a power user feature.  So what is happening is some very smart people are doing some very cool things with it, and not sharing.  It is very important that you share your effort with your Channel Partner or ANSYS, Inc so that they can not only see how people use this tool, but also modify the tool to do even more cool things. 

It would also be cool if you posted what you do on XANSYS for the masses to see.  Very cool.

Inventor of medical devices, the man behind the Segway, and FIRST backer Dean Kamenvisited the Phoenix area yesterday and today and we were lucky enough to have people from PADT invited to two different events at which he spoke.  For engineers involved in product development, this is like a visit from an NFL quarterback for most people.  He turned out to be open, engaging, and a very good speaker. 

We could go on in adoration and explore the guilt and envy we feel after seeing all that he has done.  Instead we thought we would highlight two things we learned from his visit:

1. The FIRST program that he started and still heads is making a huge difference in this country and around the world.  PADT has been peripherally involved, focusing instead more on the underwater robot scholastic competitions that are very popular here in Phoenix.  But FIRST is now huge, and is still growing.  But what we learned is the positive impact it is having: Students who participate in FIRST are 3 times more likely to become engineers, 30% more likely to attend college, and twice as likely to volunteer in their communities. Those are some positive numbers.  Those of us in the engineering world should take advantage of that and support FIRST.
   
                                                                     http://www.usfirst.org/
   
2. Second, he offered a unique perspective on how engineers see the world.  When he was young he heard the story of David and Goliath.   Most people see a religious message in this story, there are various interpretations. But as a child, Dean Kamen did not see those messages.  What he saw was that David won because he had better technology. He had a sling shot.  That is how he beat the giant.  I found that a very interesting point of view. If you don’t get it, ask an engineer.

If you ever have the chance to explore what his company, DEKA, is currently doing with a revolutionary power generation and water purification solution for areas of the globe without power or clean water, do so.  It is very leading edge stirling engine and distillation technology. 

This weeks Focus posting is not going to be very technical. In fact, it is a bit of an editorial.

Over the past five years or so we have seen a lot of companies who use ANSYS, Inc products move away from traditional face-to-face training with instructors in a classroom.  There are a lot of reasons for this.  The two most common are that 1) the company does not have a travel budget and 2) that training labor hours are considered overhead and managers all have very strict overhead restrictions.  On top of these two, many companies are just plain trying to save money on the cost of training or limiting their overall training budgets.

What we have seen is a larger number of users either trying to train themselves from manuals or downloaded training material, or people trying to do web-based training.  One can certainly learn how to use an FEA or CFD tool this way, but through our tech support we are starting to see the negative side of this shift: users only understand some of the aspects of the tools and do not have a depth of knowledge that goes beyond the basics.  So when they run into a problem that requires a move beyond those basics, or that might require a more nuanced approach, they struggle or they call tech support for on-the-spot training.

Interaction

Even though we engineers are not the most social sub-species of humans, we can still heavily benefit from face-to-face interaction during training.  When PADT teaches a training class we find that a small portion of the time is spent lecturing on and doing workshops for the basics.  Most of the time is spent answering questions that occur to students while they take these basics in.  Some are industry or user specific, some delve deeper into the tool than the training material does.  But they all provide an education to the whole class that never occurs otherwise.

We have taught, and been students in, web based training classes. The interaction is just not the same.  There are not as many questions and the instructor is not able to use body language clues to see if the class is really getting what they are saying.  In fact, we feel this is the biggest issue. When you are on the phone and sharing a screen you can not even tell if the students are listening.  So the instructor pushes on, the students drift further away, and the true benefits of the class are lost.

Make a Case for Classroom Training

The point of all of this is that we feel users out there need to make a case for real classroom training.  When your boss says that there is no travel budget, not enough overhead allocation, or just not enough money, argue strongly that the cost differences of online or self training are not that significant when compared to the productivity problem of not having deep, interactive training.  If you are a boss, admit it, you know we are right.  You should fight a bit harder for the budget because in the long run you will save money.

Another way to look at it is the relative cost of classroom training versus how much you will use the ANSYS tools you are trained on.  Even if we assume that the company you work for kind of sucks and most engineers move out of there in five years, one to three week of training is nothing when compared to five years as a user.  If your productivity is just 5% higher during that time, the savings are significant. 

Do the full classroom training.  You will not regret it.

As a full disclosure:
We are partly motivated to express this opinion by the fact that we make money doing such training classes, but in reality very few of you reading this will do training with us (although you could use us if you wanted to… hint, hint).  Most of you do your training through other Channel Partners or ANSYS, Inc.  So this posting is not entirely self serving.

About the pictures:
I find the stock photographs of what are basically models so contrived and stereotypical that they are hilarious.  So I grabbed few of my favorites to share.  I love it when they always have someone crossing their arms, looking thoughtful. 

Okay, so it’s not the ugly critter in the picture, (that on was found at my house), but the bug in ANSYS R14 can give you the willies just the same. ANSYS, Inc. is working very hard to get the situation remedied, and they will be sending out defect notices shortly.  They provided a quick-fix however, and we wanted to get it out to you as  quickly as possible. So I have done some screen captures while I ran through the fix.

The issue found is that if you close a Mechanical, or Meshing, session and then hit ‘Save’ on the project window, you may lose the contents of your Mechanical database.   The problem has arisen in R14 because ANSYS, Inc. has decreased the start up time of Mechanical by pre-loading it when Workbench is started. When you close Mechanical, it stays open in the background as an empty database. There is a 1-second ‘window of opportunity’ after you close the Mechanical editor and save the project file when the process threads are not fully synchronized.  If you save during this period, the blank session gets saved on top of the good session, and all data is lost.  If you wait longer than a second, there shouldn’t be an issue, but customers have been reporting longer times where they have still lost data.  ANSYS, Inc. is working with those customers to find out what is causing the longer times on their boxes.

Luckily the remedy is simple, and hopefully none of you will have to lose any data.  Since the issue is caused by the pre-loading of Mechanical, the remedy is to simply turn the pre-loading off.  This has to be done from  the Tools > Options menu on the Project window. Just uncheck the Pre-Load box in both the Mechanical and Meshing dialog boxes, and then close Workbench after hitting ‘OK’. The next time you open Workbench, the bug will be neutralized.

I just wish it was that easy for that creepy guy in the picture!