Running Abaqus from the command line is quite common not only on Linux machines. It's much more flexible and convenient than using Abaqus/CAE or other GUI apps in many situations. In some cases like HPC servers, cloud services, it's preferred or even obvious method.
Abaqus job can be started from the command line in three modes:
$ abaqus -j job_name -ba[ckground] This option will submit the job to run in the background (default mode). It's the default method when mode is not specified directly. In this mode the log file output will be saved in the file job-name.log in the current directory.
$ abaqus -j job_name -int[eractive] In this option the job will run in the foreground. For Abaqus/Standard the log file and for Abaqus/Explicit the status file and the log file will be output to the stdout (terminal).
$ abaqus -j job_name -seq[uential] This option will submit the job to run in the foreground. However the log/sta files will not be output to the stdout. The output info will be saved in the file job-name.log in the current directory like in the case of the background mode.
Contrary to what one might expect, submitting the Abaqus job is not a single process. Many things happen before Abaqus solver starts to solve the FEM job behind the … terminal. Understanding how Abaqus solvers are executed is not crucial but useful especially for sysadmins or devops working with Abaqus installations. It can help resolve some issues regarding Abaqus job executions e.g. in the case of queuing system configuration, vertical or web applications.
When abaqus command is invoked in the terminal, the SMALauncher (ABQLauncher in 2021 and earlier versions) program is run. In fact, abaqus command is a symlink to SMALuncher on Linux. On Windows, abaqus command is a bat file which runs SMALuncher. The SMALuncher reads configuration files (e.g. abaqus.aev, abaqus.app, abaqus.arg) and sets environment variables (e.g. ABQ_DIR/ABA_HOME, ABA_PATH, ABA_LIBRARY_PATHNAME, PYTHONPATH, etc - the full list depends on the platform). Next, SMALuncher starts the sequence of subprocesses.
That sequence depends on the phase where an analysis is performed (see Abaqus manual Abaqus/Standard and Abaqus/Explicit execution). Each phase is driven by a Python script run by SMAPython - Python distribution delivered with Abaqus. The Python drivers use the Popen method from the subprocess module to spawn next processes.
The default phase is the analysis - running the calculation of the model defined in the INP file from the very beginning stage. Running Abaqus analysis is called a job. The driver creates the job_name.com file based on a parameter given with abaqus command (e.g. number of cpus, user subroutines, etc), Abaqus settings (set of *.env files) and an input file. The *.com file is in fact a Python script. Next, the license availability is checked - the license checker eliT_CheckLicense is called with a few parameters like job name, working directory and required license. If a license is available the job_name.com is run by SMAPython. If Abauqs is run in the background mode then SMALuncher exits at this stage. In the foreground mode SMALuncher remains running until the end of the analysis.
It is worth mentioning that *.com file can be also created separately using the option createComOnly :
$ ls job_name.*job_name.inp$ abaqus createComOnly -j job_name$ ls job_name.*job_name.inp job_name.com Next, *.com file can be edited to control and to customize job parameters (e.g. the number of cpus/gpus, temp directory, parallel execution mode, memory limits etc.) in an easy way. To run a job with *.com file the Abaqus Python can be used:
$ abaqus python -u job_name.com The *.com file can be very useful to run a job using scripts, queuing systems or external applications. As an example, the simple Python script which runs a job using *.com file is hosted on GitHub for those interested.
Before Abaqus gets started (yes, the Abaqus core solver has not been run at this stage yet), the license driver eliT_DriverLM is started with similar parameters like license checker and remains running until the end of the analysis.
Next, the input file preprocessor (pre) and the preprocessor packager (in the case of Abaqus/Explicit) are run before the solvers Abaqus/Standard (standard) or Abaqus/Explicit (explicit_sp/explicit_dp) are executed at long last. Both preprocessors and solvers are run with a long list of arguments but they are not discussed here.
When the solvers have finished calculations, the postprocessors (e.g. SMASimUtility, calculator, select) are called to manage the output data finally.
To start Abaqus' job manually or even with simple scripts, the three available modes: background, interactive and sequential are effective enough in regular work for most users. However, the demonstrated example of running Abaqus jobs using *.com file directly can be useful for sysadmins or devops to manage Abaqus processes more effectively. Also developers of vertical applications using Abaqus can be interested in that solution.
Happy running Abaqus jobs!
