def test_cdread(mapdl, cleared):
random_letters = random_string(4)
mapdl.run(f"PARMTEST='{random_letters}'")
mapdl.cdwrite('all', 'model2', 'cdb')
mapdl.clear()
mapdl.cdread("db", 'model2', 'cdb')
assert random_letters in mapdl.parameters['PARMTEST']
def launch_corba(
exec_file=None,
run_location=None,
jobname=None,
nproc=None,
verbose=False,
additional_switches="",
start_timeout=60,
):
"""Start MAPDL in AAS mode
Notes
-----
The CORBA interface is likely to fail on computers with multiple
network adapters. The ANSYS RPC isn't smart enough to determine
the right adapter and will likely try to communicate on the wrong
IP.
"""
# Using stored parameters so launch command can be run from a
# cached state (when launching the GUI)
# can't run /BATCH in windows, so we trick it using "-b" and
# provide a dummy input file
if os.name == "nt":
# must be a random filename to avoid conflicts with other
# potential instances
tmp_file = "%s.inp" % random_string(10)
with open(os.path.join(run_location, tmp_file), "w") as f:
f.write("FINISH")
additional_switches += " -b -i %s -o out.txt" % tmp_file
# command must include "aas" flag to start MAPDL server
command = '"%s" -aas -j %s -np %d %s' % (
exec_file,
jobname,
nproc,
additional_switches,
)
# remove any broadcast files
broadcast_file = os.path.join(run_location, "mapdl_broadcasts.txt")
if os.path.isfile(broadcast_file):
os.remove(broadcast_file)
if verbose:
subprocess.Popen(command, shell=True, cwd=run_location)
else:
subprocess.Popen(
command,
shell=True,
cwd=run_location,
stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
# listen for broadcast file
telapsed = 0
tstart = time.time()
started_rpc = False
while telapsed < start_timeout and not started_rpc:
try:
if os.path.isfile(broadcast_file):
broadcast = open(broadcast_file).read()
# see if connection to RPC has been made
rpc_txt = "visited:collaborativecosolverunitior-set:"
started_rpc = rpc_txt in broadcast
time.sleep(0.1)
telapsed = time.time() - tstart
except KeyboardInterrupt:
raise KeyboardInterrupt
# exit if timed out
if not started_rpc:
err_str = "Unable to start ANSYS within %.1f seconds" % start_timeout
if os.path.isfile(broadcast_file):
broadcast = open(broadcast_file).read()
err_str += "\n\nLast broadcast:\n%s" % broadcast
raise TimeoutError(err_str)
# return CORBA key
keyfile = os.path.join(run_location, "aaS_MapdlId.txt")
return open(keyfile).read()
def test_no_results(mapdl, cleared, tmpdir):
pth = str(tmpdir.mkdir("tmpdir"))
mapdl.jobname = random_string()
with pytest.raises(FileNotFoundError):
mapdl.download_result(pth)
def launch_mapdl(exec_file=None, run_location=None, jobname='file',
nproc=2, ram=None, mode=None, override=False,
loglevel='ERROR', additional_switches='',
start_timeout=120, port=None,
custom_bin=None, cleanup_on_exit=True,
start_instance=True, ip=LOCALHOST,
clear_on_connect=True, log_apdl=False,
verbose_mapdl=False, **kwargs):
"""Start MAPDL locally in gRPC mode.
Parameters
----------
exec_file : str, optional
The location of the MAPDL executable. Will use the cached
location when left at the default ``None``.
run_location : str, optional
MAPDL working directory. Defaults to a temporary working
directory. If directory doesn't exist, will create one.
jobname : str, optional
MAPDL jobname. Defaults to ``'file'``.
nproc : int, optional
Number of processors. Defaults to 2.
ram : float, optional
Fixed amount of memory to request for MAPDL. If ``None``,
then MAPDL will use as much as available on the host machine.
mode : str, optional
Mode to launch MAPDL. Must be one of the following:
- ``'grpc'``
- ``'corba'``
- ``'console'``
The ``'grpc'`` mode is available on ANSYS 2021R1 or newer and
provides the best performance and stability. The ``'corba'``
mode is available from v17.0 and newer and is given legacy
support. This mode requires the additional
``ansys_corba`` module. Finally, the ``'console'`` mode
is for legacy use only Linux only prior to v17.0. This console
mode is pending depreciation.
override : bool, optional
Attempts to delete the lock file at the run_location.
Useful when a prior MAPDL session has exited prematurely and
the lock file has not been deleted.
loglevel : str, optional
Sets which messages are printed to the console. ``'INFO'``
prints out all ANSYS messages, ``'WARNING``` prints only
messages containing ANSYS warnings, and ``'ERROR'`` logs only
error messages.
additional_switches : str, optional
Additional switches for MAPDL, for example ``'aa_r'``, the
academic research license, would be added with:
- ``additional_switches="-aa_r"``
Avoid adding switches like -i -o or -b as these are already
included to start up the MAPDL server. See the notes
section for additional details.
start_timeout : float, optional
Maximum allowable time to connect to the MAPDL server.
port : int
Port to launch MAPDL gRPC on. Final port will be the first
port available after (or including) this port. Defaults to
50052. You can also override the default behavior of this
keyword argument with the environment variable
``PYMAPDL_PORT=<VALID PORT>``
custom_bin : str, optional
Path to the MAPDL custom executable. On release 2020R2 on
Linux, if ``None``, will check to see if you have
``ansys.mapdl_bin`` installed and use that executable.
cleanup_on_exit : bool, optional
Exit MAPDL when python exits or the mapdl Python instance is
garbage collected.
start_instance : bool, optional
When False, connect to an existing MAPDL instance at ``ip``
and ``port``, which default to ``'127.0.0.1'`` at 50052.
Otherwise, launch a local instance of MAPDL. You can also
override the default behavior of this keyword argument with
the environment variable ``PYMAPDL_START_INSTANCE=FALSE``.
ip : bool, optional
Used only when ``start_instance`` is ``False``. Defaults to
``'127.0.0.1'``. You can also override the default behavior of
this keyword argument with the environment variable
"PYMAPDL_IP=FALSE".
clear_on_connect : bool, optional
Used only when ``start_instance`` is ``False``. Defaults to
``True``, giving you a fresh environment when connecting to
MAPDL.
remove_temp_files : bool, optional
Removes temporary files on exit. Default ``False``.
verbose_mapdl : bool, optional
Enable printing of all output when launching and running
MAPDL. This should be used for debugging only as output can
be tracked within pymapdl. Default ``False``.
Examples
--------
Launch MAPDL using the best protocol.
>>> from ansys.mapdl.core import launch_mapdl
>>> mapdl = launch_mapdl()
Run MAPDL with shared memory parallel and specify the location of
the ansys binary.
>>> exec_file = 'C:/Program Files/ANSYS Inc/v201/ansys/bin/win64/ANSYS201.exe'
>>> mapdl = launch_mapdl(exec_file, additional_switches='-smp')
Connect to an existing instance of MAPDL at IP 192.168.1.30 and
port 50001. This is only available using the latest ``'grpc'``
mode.
>>> mapdl = launch_mapdl(start_instance=False, ip='192.168.1.30',
port=50001)
Force the usage of the CORBA protocol.
>>> mapdl = launch_mapdl(mode='corba')
Run MAPDL using the console mode (available only on Linux).
>>> mapdl = launch_mapdl('/ansys_inc/v194/ansys/bin/ansys194',
mode='console')
Notes
-----
These are the MAPDL switch options as of 2020R2 applicable for
running MAPDL as a service via gRPC. Excluded switches such as
``"-j"`` either not applicable or are set via keyword arguments.
-acc <device> : Enables the use of GPU hardware. See GPU
Accelerator Capability in the Parallel Processing Guide for more
information.
-amfg : Enables the additive manufacturing capability. Requires
an additive manufacturing license. For general information about
this feature, see AM Process Simulation in ANSYS Workbench.
-ansexe <executable> : Activates a custom mechanical APDL executable.
In the ANSYS Workbench environment, activates a custom
Mechanical APDL executable.
-custom <executable> : Calls a custom Mechanical APDL executable
See Running Your Custom Executable in the Programmer's Reference
for more information.
-db value : Initial memory allocation
Defines the portion of workspace (memory) to be used as the
initial allocation for the database. The default is 1024
MB. Specify a negative number to force a fixed size throughout
the run; useful on small memory systems.
-dis : Enables Distributed ANSYS
See the Parallel Processing Guide for more information.
-dvt : Enables ANSYS DesignXplorer advanced task (add-on).
Requires DesignXplorer.
-l <language> : Specifies a language file to use other than English
This option is valid only if you have a translated message file
in an appropriately named subdirectory in
``/ansys_inc/v201/ansys/docu`` or
``Program Files\\ANSYS\\Inc\\V201\\ANSYS\\docu``
-m <workspace> : Specifies the total size of the workspace
Workspace (memory) in megabytes used for the initial
allocation. If you omit the ``-m`` option, the default is 2 GB
(2048 MB). Specify a negative number to force a fixed size
throughout the run.
-machines <IP> : Specifies the distributed machines
Machines on which to run a Distributed ANSYS analysis. See
Starting Distributed ANSYS in the Parallel Processing Guide for
more information.
-mpi <value> : Specifies the type of MPI to use.
See the Parallel Processing Guide for more information.
-mpifile <appfile> : Specifies an existing MPI file
Specifies an existing MPI file (appfile) to be used in a
Distributed ANSYS run. See Using MPI Files in the Parallel
Processing Guide for more information.
-na <value>: Specifies the number of GPU accelerator devices
Number of GPU devices per machine or compute node when running
with the GPU accelerator feature. See GPU Accelerator Capability
in the Parallel Processing Guide for more information.
-name <value> : Defines Mechanical APDL parameters
Set mechanical APDL parameters at program start-up. The parameter
name must be at least two characters long. For details about
parameters, see the ANSYS Parametric Design Language Guide.
-p <productname> : ANSYS session product
Defines the ANSYS session product that will run during the
session. For more detailed information about the ``-p`` option,
see Selecting an ANSYS Product via the Command Line.
-ppf <license feature name> : HPC license
Specifies which HPC license to use during a parallel processing
run. See HPC Licensing in the Parallel Processing Guide for more
information.
-smp : Enables shared-memory parallelism.
See the Parallel Processing Guide for more information.
"""
# These parameters are partially used for unit testing
set_no_abort = kwargs.get('set_no_abort', True)
ip = os.environ.get('PYMAPDL_IP', ip)
if 'PYMAPDL_PORT' in os.environ:
port = int(os.environ.get('PYMAPDL_PORT'))
if port is None:
port = MAPDL_DEFAULT_PORT
# connect to an existing instance if enabled
if not get_start_instance(start_instance):
mapdl = MapdlGrpc(ip=ip, port=port, cleanup_on_exit=False,
loglevel=loglevel, set_no_abort=set_no_abort)
if clear_on_connect:
mapdl.clear()
return mapdl
# verify executable
if exec_file is None:
# Load cached path
exec_file = get_ansys_path()
if exec_file is None:
raise FileNotFoundError('Invalid or path or cannot load cached '
'ansys path. Enter one manually using '
'launch_mapdl(exec_file=)')
else: # verify ansys exists at this location
if not os.path.isfile(exec_file):
raise FileNotFoundError('Invalid ANSYS executable at "%s"\n'
% exec_file + 'Enter one manually using '
'launch_mapdl(exec_file=)')
# verify run location
if run_location is None:
temp_dir = tempfile.gettempdir()
run_location = os.path.join(temp_dir, 'ansys_%s' % random_string(10))
if not os.path.isdir(run_location):
try:
os.mkdir(run_location)
except:
raise RuntimeError('Unable to create the temporary working '
f'directory "{run_location}"\n'
'Please specify run_location=')
else:
if not os.path.isdir(run_location):
raise FileNotFoundError(f'"{run_location}" is not a valid directory')
# verify no lock file and the mode is valid
check_lock_file(run_location, jobname, override)
mode = check_mode(mode, _version_from_path(exec_file))
# known issue with distributed memory parallel
# Ubuntu ANSYS fails to launch without I_MPI_SHM_LMT
if 'smp' not in additional_switches:
if _is_ubuntu():
os.environ['I_MPI_SHM_LMT'] = 'shm'
# cache start parameters
if mode in ['console', 'corba']:
start_parm = {'exec_file': exec_file,
'run_location': run_location,
'jobname': jobname,
'nproc': nproc,
'additional_switches': additional_switches,
'start_timeout': start_timeout}
else:
start_parm = {'exec_file': exec_file,
'jobname': jobname,
'nproc': nproc,
'ram': ram,
'run_location': run_location,
'additional_switches': additional_switches,
'custom_bin': custom_bin,
'override': override,
'timeout': start_timeout}
if mode == 'console':
from ansys.mapdl.core.mapdl_console import MapdlConsole
mapdl = MapdlConsole(loglevel=loglevel, log_apdl=log_apdl,
**start_parm)
elif mode == 'corba':
try:
# pending deprication to ansys-mapdl-corba
from ansys.mapdl.core.mapdl_corba import MapdlCorba
except ImportError:
raise ImportError('To use this feature, install the MAPDL CORBA package'
' with:\n\n'
' pip install ansys_corba')
broadcast = kwargs.get('log_broadcast', False)
mapdl = MapdlCorba(loglevel=loglevel, log_apdl=log_apdl,
log_broadcast=broadcast, verbose=verbose_mapdl,
**start_parm)
elif mode == 'grpc':
port, actual_run_location = launch_grpc(port=port, verbose=verbose_mapdl,
**start_parm)
mapdl = MapdlGrpc(ip=LOCALHOST, port=port,
cleanup_on_exit=cleanup_on_exit,
loglevel=loglevel, set_no_abort=set_no_abort,
remove_temp_files=kwargs.pop('remove_temp_files', False),
**start_parm)
if run_location is None:
mapdl._path = actual_run_location
else:
raise ValueError('Invalid mode %s' % mode)
return mapdl
def launch_mapdl(
exec_file=None,
run_location=None,
jobname="file",
nproc=2,
ram=None,
mode=None,
override=False,
loglevel="ERROR",
additional_switches="",
start_timeout=120,
port=None,
cleanup_on_exit=True,
start_instance=True,
ip=LOCALHOST,
clear_on_connect=True,
log_apdl=False,
verbose_mapdl=False,
license_server_check=True,
license_type=None,
**kwargs,
):
"""Start MAPDL locally in gRPC mode.
Parameters
----------
exec_file : str, optional
The location of the MAPDL executable. Will use the cached
location when left at the default ``None``.
run_location : str, optional
MAPDL working directory. Defaults to a temporary working
directory. If directory doesn't exist, will create one.
jobname : str, optional
MAPDL jobname. Defaults to ``'file'``.
nproc : int, optional
Number of processors. Defaults to 2.
ram : float, optional
Fixed amount of memory to request for MAPDL. If ``None``,
then MAPDL will use as much as available on the host machine.
mode : str, optional
Mode to launch MAPDL. Must be one of the following:
- ``'grpc'``
- ``'corba'``
- ``'console'``
The ``'grpc'`` mode is available on ANSYS 2021R1 or newer and
provides the best performance and stability. The ``'corba'``
mode is available from v17.0 and newer and is given legacy
support. This mode requires the additional
``ansys_corba`` module. Finally, the ``'console'`` mode
is for legacy use only Linux only prior to v17.0. This console
mode is pending depreciation.
override : bool, optional
Attempts to delete the lock file at the run_location.
Useful when a prior MAPDL session has exited prematurely and
the lock file has not been deleted.
loglevel : str, optional
Sets which messages are printed to the console. ``'INFO'``
prints out all ANSYS messages, ``'WARNING``` prints only
messages containing ANSYS warnings, and ``'ERROR'`` logs only
error messages.
additional_switches : str, optional
Additional switches for MAPDL, for example ``'aa_r'``, the
academic research license, would be added with:
- ``additional_switches="-aa_r"``
Avoid adding switches like -i -o or -b as these are already
included to start up the MAPDL server. See the notes
section for additional details.
start_timeout : float, optional
Maximum allowable time to connect to the MAPDL server.
port : int
Port to launch MAPDL gRPC on. Final port will be the first
port available after (or including) this port. Defaults to
50052. You can also override the default behavior of this
keyword argument with the environment variable
``PYMAPDL_PORT=<VALID PORT>``
custom_bin : str, optional
Path to the MAPDL custom executable. On release 2020R2 on
Linux, if ``None``, will check to see if you have
``ansys.mapdl_bin`` installed and use that executable.
cleanup_on_exit : bool, optional
Exit MAPDL when python exits or the mapdl Python instance is
garbage collected.
start_instance : bool, optional
When False, connect to an existing MAPDL instance at ``ip``
and ``port``, which default to ``'127.0.0.1'`` at 50052.
Otherwise, launch a local instance of MAPDL. You can also
override the default behavior of this keyword argument with
the environment variable ``PYMAPDL_START_INSTANCE=FALSE``.
ip : bool, optional
Used only when ``start_instance`` is ``False``. Defaults to
``'127.0.0.1'``. You can also override the default behavior of
this keyword argument with the environment variable
"PYMAPDL_IP=FALSE".
clear_on_connect : bool, optional
Used only when ``start_instance`` is ``False``. Defaults to
``True``, giving you a fresh environment when connecting to
MAPDL.
log_apdl : str, optional
Enables logging every APDL command to the local disk. This
can be used to "record" all the commands that are sent to
MAPDL via PyMAPDL so a script can be run within MAPDL without
PyMAPDL.
remove_temp_files : bool, optional
Removes temporary files on exit. Default ``False``.
verbose_mapdl : bool, optional
Enable printing of all output when launching and running
MAPDL. This should be used for debugging only as output can
be tracked within pymapdl. Default ``False``.
license_server_check : bool, optional
Check if the license server is available if MAPDL fails to
start. Only available on ``mode='grpc'``. Defaults ``True``.
license_type : str, optional
Enable license type selection. You can input a string for its
license name (for example ``'meba'`` or ``'ansys'``) or its description
("enterprise solver" or "enterprise" respectively).
You can also use legacy licenses (for example ``'aa_t_a'``) but it will
also raise a warning. If it is not used (``None``), no specific license
will be requested, being up to the license server to provide a specific
license type. Default is ``None``.
Notes
-----
These are the MAPDL switch options as of 2020R2 applicable for
running MAPDL as a service via gRPC. Excluded switches such as
``"-j"`` either not applicable or are set via keyword arguments.
-acc <device> : Enables the use of GPU hardware. See GPU
Accelerator Capability in the Parallel Processing Guide for more
information.
-amfg : Enables the additive manufacturing capability. Requires
an additive manufacturing license. For general information about
this feature, see AM Process Simulation in ANSYS Workbench.
-ansexe <executable> : Activates a custom mechanical APDL executable.
In the ANSYS Workbench environment, activates a custom
Mechanical APDL executable.
-custom <executable> : Calls a custom Mechanical APDL executable
See Running Your Custom Executable in the Programmer's Reference
for more information.
-db value : Initial memory allocation
Defines the portion of workspace (memory) to be used as the
initial allocation for the database. The default is 1024
MB. Specify a negative number to force a fixed size throughout
the run; useful on small memory systems.
-dis : Enables Distributed ANSYS
See the Parallel Processing Guide for more information.
-dvt : Enables ANSYS DesignXplorer advanced task (add-on).
Requires DesignXplorer.
-l <language> : Specifies a language file to use other than English
This option is valid only if you have a translated message file
in an appropriately named subdirectory in
``/ansys_inc/v201/ansys/docu`` or
``Program Files\\ANSYS\\Inc\\V201\\ANSYS\\docu``
-m <workspace> : Specifies the total size of the workspace
Workspace (memory) in megabytes used for the initial
allocation. If you omit the ``-m`` option, the default is 2 GB
(2048 MB). Specify a negative number to force a fixed size
throughout the run.
-machines <IP> : Specifies the distributed machines
Machines on which to run a Distributed ANSYS analysis. See
Starting Distributed ANSYS in the Parallel Processing Guide for
more information.
-mpi <value> : Specifies the type of MPI to use.
See the Parallel Processing Guide for more information.
-mpifile <appfile> : Specifies an existing MPI file
Specifies an existing MPI file (appfile) to be used in a
Distributed ANSYS run. See Using MPI Files in the Parallel
Processing Guide for more information.
-na <value>: Specifies the number of GPU accelerator devices
Number of GPU devices per machine or compute node when running
with the GPU accelerator feature. See GPU Accelerator Capability
in the Parallel Processing Guide for more information.
-name <value> : Defines Mechanical APDL parameters
Set mechanical APDL parameters at program start-up. The parameter
name must be at least two characters long. For details about
parameters, see the ANSYS Parametric Design Language Guide.
-p <productname> : ANSYS session product
Defines the ANSYS session product that will run during the
session. For more detailed information about the ``-p`` option,
see Selecting an ANSYS Product via the Command Line.
-ppf <license feature name> : HPC license
Specifies which HPC license to use during a parallel processing
run. See HPC Licensing in the Parallel Processing Guide for more
information.
-smp : Enables shared-memory parallelism.
See the Parallel Processing Guide for more information.
Examples
--------
Launch MAPDL using the best protocol.
>>> from ansys.mapdl.core import launch_mapdl
>>> mapdl = launch_mapdl()
Run MAPDL with shared memory parallel and specify the location of
the ansys binary.
>>> exec_file = 'C:/Program Files/ANSYS Inc/v201/ansys/bin/win64/ANSYS201.exe'
>>> mapdl = launch_mapdl(exec_file, additional_switches='-smp')
Connect to an existing instance of MAPDL at IP 192.168.1.30 and
port 50001. This is only available using the latest ``'grpc'``
mode.
>>> mapdl = launch_mapdl(start_instance=False, ip='192.168.1.30',
port=50001)
Force the usage of the CORBA protocol.
>>> mapdl = launch_mapdl(mode='corba')
Run MAPDL using the console mode (available only on Linux).
>>> mapdl = launch_mapdl('/ansys_inc/v194/ansys/bin/ansys194',
mode='console')
"""
# These parameters are partially used for unit testing
set_no_abort = kwargs.get("set_no_abort", True)
ip = os.environ.get("PYMAPDL_IP", ip)
if "PYMAPDL_PORT" in os.environ:
port = int(os.environ.get("PYMAPDL_PORT"))
if port is None:
port = MAPDL_DEFAULT_PORT
# connect to an existing instance if enabled
if not get_start_instance(start_instance):
mapdl = MapdlGrpc(
ip=ip,
port=port,
cleanup_on_exit=False,
loglevel=loglevel,
set_no_abort=set_no_abort,
)
if clear_on_connect:
mapdl.clear()
return mapdl
# verify executable
if exec_file is None:
# Load cached path
exec_file = get_ansys_path()
if exec_file is None:
raise FileNotFoundError(
"Invalid exec_file path or cannot load cached "
"mapdl path. Enter one manually by specifying "
"exec_file=")
else: # verify ansys exists at this location
if not os.path.isfile(exec_file):
raise FileNotFoundError(
f'Invalid MAPDL executable at "{exec_file}"\n'
"Enter one manually using exec_file=")
# verify run location
if run_location is None:
temp_dir = tempfile.gettempdir()
run_location = os.path.join(temp_dir, "ansys_%s" % random_string(10))
if not os.path.isdir(run_location):
try:
os.mkdir(run_location)
except:
raise RuntimeError("Unable to create the temporary working "
f'directory "{run_location}"\n'
"Please specify run_location=")
else:
if not os.path.isdir(run_location):
raise FileNotFoundError(
f'"{run_location}" is not a valid directory')
# verify no lock file and the mode is valid
check_lock_file(run_location, jobname, override)
mode = check_mode(mode, _version_from_path(exec_file))
# cache start parameters
additional_switches = _validate_add_sw(additional_switches, exec_file,
kwargs.pop("force_intel", False))
if isinstance(license_type, str):
# In newer license server versions an invalid license name just get discarded and produces no effect or warning.
# For example:
# ```bash
# mapdl.exe -p meba # works fine because 'meba' is a valid license in ALLOWABLE_LICENSES.
# mapdl.exe -p yoyoyo # The -p flag is ignored and it run the default license.
# ```
#
# In older versions probably it might raise an error. But not sure.
license_type = license_type.lower().strip()
if 'enterprise' in license_type and 'solver' not in license_type:
license_type = 'ansys'
elif 'enterprise' in license_type and 'solver' in license_type:
license_type = 'meba'
elif 'premium' in license_type:
license_type = 'mech_2'
elif 'pro' in license_type:
license_type = 'mech_1'
elif license_type not in ALLOWABLE_LICENSES:
allow_lics = [f"'{each}'" for each in ALLOWABLE_LICENSES]
warn_text = \
f"The keyword argument 'license_type' value ('{license_type}') is not a recognized license name or has been deprecated.\n" + \
"Still PyMAPDL will try to use it but in older versions you might experience problems connecting to the server.\n" + \
f"Recognized license names: {' '.join(allow_lics)}"
warnings.warn(warn_text, UserWarning)
additional_switches += ' -p ' + license_type
LOG.debug(
f"Using specified license name '{license_type}' in the 'license_type' keyword argument."
)
elif '-p ' in additional_switches:
# There is already a license request in additional switches.
license_type = re.findall(
r'-p \b(\w*)',
additional_switches)[0] # getting only the first product license.
if license_type not in ALLOWABLE_LICENSES:
allow_lics = [f"'{each}'" for each in ALLOWABLE_LICENSES]
warn_text = \
f"The additional switch product value ('-p {license_type}') is not a recognized license name or has been deprecated.\n" + \
"Still PyMAPDL will try to use it but in older versions you might experience problems connecting to the server.\n" + \
f"Recognized license names: {' '.join(allow_lics)}"
warnings.warn(warn_text, UserWarning)
LOG.warning(warn_text)
LOG.debug(
f"Using specified license name '{license_type}' in the additional switches parameter."
)
elif license_type is not None:
raise TypeError(
"The argument 'license_type' does only accept str or None.")
start_parm = {
"exec_file": exec_file,
"run_location": run_location,
"additional_switches": additional_switches,
"jobname": jobname,
"nproc": nproc,
}
if mode in ["console", "corba"]:
start_parm["start_timeout"] = start_timeout
else:
start_parm["ram"] = ram
start_parm["override"] = override
start_parm["timeout"] = start_timeout
# Check the license server
if license_server_check:
# configure timeout to be 90% of the wait time of the startup
# time for Ansys.
lic_check = LicenseChecker(timeout=start_timeout * 0.9,
verbose=verbose_mapdl)
lic_check.start()
try:
if mode == "console":
from ansys.mapdl.core.mapdl_console import MapdlConsole
mapdl = MapdlConsole(loglevel=loglevel,
log_apdl=log_apdl,
**start_parm)
elif mode == "corba":
try:
# pending deprication to ansys-mapdl-corba
from ansys.mapdl.core.mapdl_corba import MapdlCorba
except ImportError:
raise ImportError(
"To use this feature, install the MAPDL CORBA package"
" with:\n\npip install ansys_corba") from None
broadcast = kwargs.get("log_broadcast", False)
mapdl = MapdlCorba(
loglevel=loglevel,
log_apdl=log_apdl,
log_broadcast=broadcast,
verbose=verbose_mapdl,
**start_parm,
)
elif mode == "grpc":
port, actual_run_location = launch_grpc(port=port,
verbose=verbose_mapdl,
ip=ip,
**start_parm)
mapdl = MapdlGrpc(
ip=ip,
port=port,
cleanup_on_exit=cleanup_on_exit,
loglevel=loglevel,
set_no_abort=set_no_abort,
remove_temp_files=kwargs.pop("remove_temp_files", False),
log_apdl=log_apdl,
**start_parm,
)
if run_location is None:
mapdl._path = actual_run_location
except Exception as exception:
# Failed to launch for some reason. Check if failure was due
# to the license check
if license_server_check:
lic_check.check()
# pass
raise exception
return mapdl