Version 1.2

Version 1.2 - Transonic correction and analytical gradients

This version mainly features a transonic solver and analytical pressure derivatives.

Changes

• Add transonic correction
• Add analytical gradients
• Add feature to deform the body
• Fix calculation of motion-induced velocity and unsteady pressure
• Refactor APIs and utilities

Notes

Transonic correction
The unsteady pressure solution can now be corrected by higher-fidelity data (typically obtained from CFD) to include transonic and viscous effects.
Analytical gradients
Although CoDiPack works well, its memory footprint is too large for practical unsteady cases (see #6). Analytical pressure and aerodynamic forces gradients have therefore been implemented so that flutter constrained optimization can be performed within a reasonable computational time.
Body deformation
The body nodes can now be set to new positions for aeroelastic and optimization purposes.
Formulation fixes
The calculation of the surface velocity induced by a rigid pitching motion has been corrected to use original instead of compressible coordinates. Additionally, a mistake in the calculation of the unsteady pressure coefficient has been fixed.
Refactoring
The default values in the API have been refactored. The slicing utility now also outputs z-coordinates.

Tests

• Ubuntu 22.04 (gcc 11, python 3.10)

sdpm/utils.py

@@ -91,9 +91,12 @@ def create_slices(body, sol, fname, ys):
     for i in range(len(ys)):
         # get data on cut section
         coords, connct, cvalues = extract_data(cut_grid(grid, [0., ys[i], 0.]), snames)
-        # normalize x-coordinate by local chord
-        xc = np.zeros((coords.shape[0], 1))
-        xc[:,0] = (coords[:,0] - min(coords[:,0])) / (max(coords[:,0]) - min(coords[:,0]))
+        # normalize x and z-coordinates by local chord
+        xc = np.zeros((coords.shape[0], 2))
+        ile = np.argmin(coords[:,0]) # LE index
+        crd = max(coords[:,0]) - min(coords[:,0]) # chord
+        xc[:,0] = (coords[:,0] - coords[ile,0]) / crd
+        xc[:,1] = (coords[:,2] - coords[ile,2]) / crd
         # average value at points from values at cell center
         nvalues = np.zeros((coords.shape[0], len(sol.keys())))
         for j in range(connct.shape[0]):
@@ -101,16 +104,16 @@ def create_slices(body, sol, fname, ys):
             for k in range(len(pids)):
                 for l in range(len(sol.keys())):
                     nvalues[connct[j][k], l] += cvalues[snames[l]][j] / len(pids)
-        # create dataset holding x-coordinates and values and sort it
+        # create dataset holding coordinates and values and sort it
         xc_vals = np.hstack((xc, nvalues))
         sort(connct, xc_vals)
         xc_vals = np.vstack((xc_vals, xc_vals[0,:]))
         # write to file
-        hdr = 'x/c'
+        hdr = f'y = {ys[i]}, c = {crd}\n'
+        hdr += '{:>9s}, {:>10s}'.format('x/c', 'z/c')
         for name in snames:
-            hdr += f', {name}'
-        hdr += f'\ny = {ys[i]}'
-        np.savetxt(fname+f'_slice_{i}.dat', xc_vals, fmt='%1.5e', delimiter=',', header=hdr)
+            hdr += ', {:>10s}'.format(name)
+        np.savetxt(fname+f'_slice_{i}.dat', xc_vals, fmt='%+1.4e', delimiter=',', header=hdr)
 
 def interpolate_modes(fname, surf_nodes, flat=True):
     """Read modal displacements and interpolate them on surface grid
@@ -151,3 +154,32 @@ def interpolate_modes(fname, surf_nodes, flat=True):
     for i in range(n_modes):
         iamp[i] = np.linalg.norm(np.reshape(imodes[:, 3*i:3*i+3], (3 * len(surf_nodes), 1)))
     return imodes, iamp
+
+def interpolate_pressure(fname, surf_nodes):
+    """Read pressure derivative and interpolate it on surface grid
+
+    Parameters
+    ----------
+    fname : string
+        name of the CSV file containing the pressure derivative
+    surf_nodes : array
+        nodes of surface grid
+
+    Return
+    ------
+    icp : (n, 1) ndarray
+        interpolated pressure derivative (n is the number of surf_nodes)
+    """
+    import numpy as np
+    import scipy.interpolate as spip
+    # Read pressure and remove duplicates
+    cp = np.loadtxt(fname, delimiter=',', skiprows=1)
+    _, idx = np.unique(cp[:,:3], axis=0, return_index=True)
+    cp = cp[idx,:]
+    # Interpolate on surface mesh
+    xyz_surf = np.zeros((len(surf_nodes), 3))
+    for i, n in enumerate(surf_nodes):
+        for j in range(3):
+            xyz_surf[i,j] = n.getCoords()[j]
+    icp = spip.RBFInterpolator(cp[:,:3], cp[:,3:], smoothing=1e-6)(xyz_surf)
+    return icp