Extract the Real and Imag part of the displacement from Harmonic analysis without using get() command

[Victor-Kao]

Hi everyone!

I have a question regarding returning the real and imag part of the displacement from Harmonic analysis.
In my following example, I obtain the frequency response function (FRF) under the base excitation, and I extract the real and image parts of the result using the get command. However, get command is very slow! In my real case, the time consumed on obtaining the data using the get command sometimes can be more than solving.

Therefore, I would like to know if there is any way that I can extract displacement from the result stored by the nsol command without using the get command or if there is any way I can accelerate this process.

Thank you in advance!

import matplotlib.pyplot as plt
import numpy as np
import time 
#mapdl = launch_mapdl(nproc=4)

mapdl.clear()

## Prep7 #######################################################
mapdl.prep7()
mapdl.units("SI")  # SI - International system (m, kg, s, K).

# Create Node
mapdl.n(1,"0","0","0")
mapdl.n(2,"0","0","10")

# Define mass21 element 
mapdl.et(1, "MASS21", kop3=0)
mapdl.type(1)
mapdl.real(1)
mapdl.r(1,100,300,200)
mapdl.e(2)

mapdl.et(2, "COMBIN14", kop2=3)
mapdl.type(2)
mapdl.real(2)
k = (4*np.pi**2)*20000
mapdl.r(2,k,1000)
mapdl.e(1,2)

## SOLU #######################################################
mapdl.run("/SOLU")
mapdl.antype(3)  
mapdl.eqslv('SPARSE')
mapdl.hropt('FULL')
mapdl.harfrq("0.1","100")

substep = int(100/0.2)
min_sub = int(100/0.1)
max_sub = int(100/0.5)
mapdl.nsubst(substep,min_sub,max_sub)

mapdl.dmprat("0.05")
mapdl.d("1","UZ",1)
mapdl.kbc(1)
mapdl.solve()
mapdl.finish()

## POST #######################################################
mapdl.post26()
acc_z_1F = mapdl.nsol("2","2","U","Z")

freq_values = np.unique(mapdl.post_processing.frequency_values)

Num_Freq = len(freq_values)
#
U_real = np.zeros(Num_Freq)
U_imag = np.zeros(Num_Freq)
U_ampl = np.zeros(Num_Freq)
#
# get command is very slow!!
for i_freq in range(Num_Freq):
    U_real[i_freq] = mapdl.get("U","VARI",2,"REAL",freq_values[i_freq])
    U_imag[i_freq] = mapdl.get("U","VARI",2,"IMAG",freq_values[i_freq])
    U_ampl[i_freq] = mapdl.get("U","VARI",2,"AMPL",freq_values[i_freq])

plt.plot(freq_values, np.sqrt(np.power(U_real,2)+np.power(U_imag,2)), label="AMPL = sqrt(R^2+I^2)",linestyle="-.")
plt.plot(freq_values, U_ampl, label="AMPL",linestyle=":")
plt.legend()
plt.xlabel("freq (Hz)")
plt.ylabel("AMPL")
plt.show()

[germa89]

Hi @Victor-Kao

To speed up your code you could use the non_interactive mode, but some adjustments need to be done.

Try the following:

freq_values = np.unique(mapdl.post_processing.frequency_values)

Num_Freq = len(freq_values)

test = False

if test:
    mapdl.parameters['U_real'] = np.zeros(Num_Freq)
    mapdl.parameters['U_imag'] = np.zeros(Num_Freq)
    mapdl.parameters['U_ampl'] = np.zeros(Num_Freq)

    # get command is very slow!!
    with mapdl.non_interactive:
        for i_freq in range(Num_Freq+1):
            mapdl.run(f"*GET,U_real({i_freq+1}),VARI,2,REAL,{freq_values[i_freq]}")
            mapdl.run(f"*GET,U_imag({i_freq+1}),VARI,2,IMAG,{freq_values[i_freq]}")
            mapdl.run(f"*GET,U_ampl({i_freq+1}),VARI,2,AMPL,{freq_values[i_freq]}")

    U_real = mapdl.parameters['U_real']
    U_imag = mapdl.parameters['U_imag']
    U_ampl = mapdl.parameters['U_ampl']


else:
    # default
    #
    U_real = np.zeros(Num_Freq)
    U_imag = np.zeros(Num_Freq)
    U_ampl = np.zeros(Num_Freq)
    #
    # get command is very slow!!
    for i_freq in range(Num_Freq):
        U_real[i_freq] = mapdl.get("U","VARI",2,"REAL",freq_values[i_freq])
        U_imag[i_freq] = mapdl.get("U","VARI",2,"IMAG",freq_values[i_freq])
        U_ampl[i_freq] = mapdl.get("U","VARI",2,"AMPL",freq_values[i_freq])

After running the first time, it goes down to 2s vs 4s (your version).

[mikerife]

Hi @Victor-Kao & @germa89
A faster way would be to VGET the real and imaginary part of the NSOL variable to their own arrays. Then use them as you see fit. So something like:

## POST #######################################################
mapdl.post26()
acc_z_1F = mapdl.nsol("2","2","U","Z")

freq_values = np.unique(mapdl.post_processing.frequency_values)

# put the real and imaginary parts of acc_z_1F into unique mapdl array parameters
mapdl.vget(acc_z_1F_R, 2, '', 0)
mapdl.vget(acc_z_1F_IM, 2, '', 1)

Then when you want to work with them, just use mapdl.parameter["acc_z_1F_R"] for the real part and similar for the imaginary.
Mike

[Victor-Kao]

Hi @germa89 and @mikerife

Thank you very much for helping! The vget command is what I am looking for!!
It works pretty well!

Best,
Victor

[germa89]

For curiosity I time the three approaches. Clearly @mikerife option is better (as expected). This difference will be even bigger when the number of frequencies is higher.

Results

I do not start MAPDL each time, I just connect to the docker container.

@Victor-Kao version:

Benchmark 1: python tmp/tmp2.py 0
  Time (mean ± σ):      6.562 s ±  0.217 s    [User: 2.974 s, System: 1.692 s]
  Range (min … max):    6.347 s …  7.023 s    10 runs

@germa89 version

Benchmark 1: python tmp/tmp2.py 1
  Time (mean ± σ):      4.990 s ±  0.233 s    [User: 2.199 s, System: 1.396 s]
  Range (min … max):    4.769 s …  5.448 s    10 runs

@mikerife

Benchmark 1: python tmp/tmp2.py 2
  Time (mean ± σ):      4.139 s ±  0.107 s    [User: 1.865 s, System: 1.686 s]
  Range (min … max):    3.963 s …  4.293 s    10 runs

Code

Code

You can time the tests on MacOS using:

time python file.py %test_value%

I did use hyperfine --warmup 2 though.

Where test_value is:

• 0 for @Victor-Kao option
• 1 for @germa89 option
• 2 for @mikerife

import sys
import matplotlib.pyplot as plt
import numpy as np
import time 
from ansys.mapdl.core import launch_mapdl

mapdl = launch_mapdl(start_instance=False, port=50053)

mapdl.clear()

## Prep7 #######################################################
mapdl.prep7()
mapdl.units("SI")  # SI - International system (m, kg, s, K).

# Create Node
mapdl.n(1,"0","0","0")
mapdl.n(2,"0","0","10")

# Define mass21 element 
mapdl.et(1, "MASS21", kop3=0)
mapdl.type(1)
mapdl.real(1)
mapdl.r(1,100,300,200)
mapdl.e(2)

mapdl.et(2, "COMBIN14", kop2=3)
mapdl.type(2)
mapdl.real(2)
k = (4*np.pi**2)*20000
mapdl.r(2,k,1000)
mapdl.e(1,2)

## SOLU #######################################################
mapdl.run("/SOLU")
mapdl.antype(3)  
mapdl.eqslv('SPARSE')
mapdl.hropt('FULL')
mapdl.harfrq("0.1","100")

substep = int(100/0.2)
min_sub = int(100/0.1)
max_sub = int(100/0.5)
mapdl.nsubst(substep,min_sub,max_sub)

mapdl.dmprat("0.05")
mapdl.d("1","UZ",1)
mapdl.kbc(1)
mapdl.solve()
mapdl.finish()

## POST #######################################################
mapdl.post26()
acc_z_1F = mapdl.nsol("2","2","U","Z")

freq_values = np.unique(mapdl.post_processing.frequency_values)

Num_Freq = len(freq_values)

if len(sys.argv) > 1:
    test = int(sys.argv[1])
else:
    test = 2

if test == 0:
    print("default")
    # default
    #
    U_real = np.zeros(Num_Freq)
    U_imag = np.zeros(Num_Freq)
    U_ampl = np.zeros(Num_Freq)
    #
    # get command is very slow!!
    for i_freq in range(Num_Freq):
        U_real[i_freq] = mapdl.get("U","VARI",2,"REAL",freq_values[i_freq])
        U_imag[i_freq] = mapdl.get("U","VARI",2,"IMAG",freq_values[i_freq])
        U_ampl[i_freq] = mapdl.get("U","VARI",2,"AMPL",freq_values[i_freq])

elif test==1:
    print("Ger")
    mapdl.parameters['U_real'] = np.zeros(Num_Freq)
    mapdl.parameters['U_imag'] = np.zeros(Num_Freq)
    mapdl.parameters['U_ampl'] = np.zeros(Num_Freq)

    with mapdl.non_interactive:
        for i_freq in range(Num_Freq):
            mapdl.run(f"*GET,U_real({i_freq+1}),VARI,2,REAL,{freq_values[i_freq]}")
            mapdl.run(f"*GET,U_imag({i_freq+1}),VARI,2,IMAG,{freq_values[i_freq]}")
            mapdl.run(f"*GET,U_ampl({i_freq+1}),VARI,2,AMPL,{freq_values[i_freq]}")

    U_real = mapdl.parameters['U_real']
    U_imag = mapdl.parameters['U_imag']
    U_ampl = mapdl.parameters['U_ampl']

elif test ==2:
    ## POST #######################################################
    print("Mike")
    mapdl.post26()
    acc_z_1F = mapdl.nsol("2","2","U","Z")

    freq_values = np.unique(mapdl.post_processing.frequency_values)

    # put the real and imaginary parts of acc_z_1F into unique mapdl array parameters
    U_real = mapdl.vget("acc_z_1F_R", 2, '', 0)
    U_imag = mapdl.vget("acc_z_1F_IM", 2, '', 1)

    U_ampl = (U_real**2 + U_imag**2)**0.5

else:
    raise ValueError()

plt.plot(freq_values, np.sqrt(np.power(U_real,2)+np.power(U_imag,2)), label="AMPL = sqrt(R^2+I^2)",linestyle="-.")
plt.plot(freq_values, U_ampl, label="AMPL",linestyle=":")
plt.legend()
plt.xlabel("freq (Hz)")
plt.ylabel("AMPL")
# plt.show()