def get_vertical_profile_xy(filepath, name, time, xloc, zloc): """Return the profile along the y direction at given x and z locations. The function loads the solution of from the volume probe at a given time. The solution is first interpolated along the z direction and then, along the x direction. Parameters ---------- filepath : pathlib.Path Path of the file with the volume probe data. name : str Name of the variable to load. time : float Time value at which to load the data. xloc : float Location along the x direction at which to interpolate data. zloc : float Location along the z direction at which to interpolate data. Returns ------- numpy.ndarray y locations along the profile as a 1D array of floats. numpy.ndarray Values of the interpolated variable as a 1D array of floats. """ probe = petibmpy.ProbeVolume(name, name) (x, y, z), u = probe.read_hdf5(filepath, time) u = petibmpy.linear_interpolation(u, z, zloc) u = numpy.swapaxes(u, 0, 1) u = petibmpy.linear_interpolation(u, x, xloc) assert y.size == u.size return y, u
def get_field_slices_2d(grid, field, xlocs): x, y, z = grid # Interpolate field at given x-locations. field_slices = [] field = numpy.swapaxes(field, 0, -1) # swap z and x axes for xloc in xlocs: field_slice = petibmpy.linear_interpolation(field, x, xloc) field_slices.append(field_slice) # Return the y and z gridline coordinates # and the slices of the field solution. return (y, z), field_slices
def test_linear_interpolation(self): """Test the function to do linear interpolation along first axis.""" nz = numpy.shape(self.values)[0] z = numpy.linspace(0.0, 1.0, num=nz) i = -2 # Exact location. values = petibmpy.linear_interpolation(self.values, z, z[i]) self.assertTrue(numpy.allclose(values, self.values[i])) # Mid location. zi = 0.5 * (z[i - 1] + z[i]) values = petibmpy.linear_interpolation(self.values, z, zi) self.assertTrue( numpy.allclose(values, 0.5 * (self.values[i - 1] + self.values[i]))) # Compare results to scipy.interpolate.interp1d. nx = 100 x = numpy.linspace(0.0, 1.0, num=nx) values = numpy.random.rand(nx) xi = random.random() v1 = petibmpy.linear_interpolation(values, x, xi) f = interpolate.interp1d(x, values) self.assertAlmostEqual(v1, f([xi])[0], places=12)
# ---------------------------------------------------------------------------- # Plot the 2D slice of the streamwise vorticity in the y/z plane at x/c = 0.3. # ---------------------------------------------------------------------------- # Load the gridline coordinates from file. filepath = datadir / 'grid.h5' x, y, z = petibmpy.read_grid_hdf5(filepath, 'wx') # Load the field solution from file. filepath = datadir / '{:0>7}.h5'.format(timestep) wx = petibmpy.read_field_hdf5(filepath, 'wx') # Interpolate the vorticity component in the y/z plane in the near wake. xloc = 0.3 # location along the x direction (near wake) wx_tmp = numpy.swapaxes(wx, -1, 0) wx_xloc = petibmpy.linear_interpolation(wx_tmp, x, xloc) # Create the Matplotlib figure. fig, ax = pyplot.subplots(figsize=(4.0, 4.0)) ax.set_xlabel('z/c') ax.set_ylabel('y/c') # Add wing to the plot. ax.add_patch( patches.Ellipse((0.0, 0.0), config.S, config.c * numpy.sin(theta), edgecolor='C0', linewidth=3.0, facecolor='gray', alpha=0.5))
adir = rootdir / 'data' filepath = adir / 'ghia_et_al_1982_lid_driven_cavity.dat' yu_g, uc_g, xv_g, vc_g = load_data_ghia_et_al_1982(filepath, str(Re)) # Load gridlines and velocity fields. simudir = maindir / f'liddrivencavity2dRe{Re}' datadir = simudir / 'output' filepath = datadir / 'grid.h5' xu, yu = petibmpy.read_grid_hdf5(filepath, 'u') xv, yv = petibmpy.read_grid_hdf5(filepath, 'v') filepath = datadir / f'{timestep:0>7}.h5' u = petibmpy.read_field_hdf5(filepath, 'u') v = petibmpy.read_field_hdf5(filepath, 'v') # Interpolate solution at centerlines of the cavity. uc = petibmpy.linear_interpolation(u.T, xu, 0.5) vc = petibmpy.linear_interpolation(v, yv, 0.5) # Plot the velocity profiles. ax1.plot(yu, uc, label=f'Re = {Re}') label = ('Ghia et al. (1982)' if Re == Res[-1] else None) ax1.plot(yu_g, uc_g, label=label, linewidth=0, color='black', marker='o', markerfacecolor='none') ax2.plot(xv, vc, label=f'Re = {Re}') ax2.plot(xv_g, vc_g,
# Load information about the text annotations to add to figures. filepath = pathlib.Path(__file__).parent / 'wx_slices_annotations.yaml' with open(filepath, 'r') as infile: annot = yaml.safe_load(infile)['xlocs'] # Loop over the slices to compute and plot. for xloc in xlocs: print(f'[xloc = {xloc}] Computing and plotting wx slice ...') # Initialize figure. fig = pyplot.figure(figsize=(width / scale, height / scale), dpi=300, frameon=False) ax = pyplot.Axes(fig, [0.0, 0.0, 1.0, 1.0]) # Interpolate the 3D vorticity compenent at given x location. wx_xloc = petibmpy.linear_interpolation(wx, x, xloc) # Represent the wing on the figure. ax.add_patch(patches.Ellipse((0.0, 0.0), config.S, config.c * numpy.sin(theta), edgecolor='black', facecolor='gray', alpha=0.5)) # Add the contours of the vorticity component. contourf_levels = numpy.linspace(-5.0, 5.0, num=50) contour_levels = numpy.linspace(-5.0, 5.0, num=10) ax.contourf(z - config.S / 2, y, wx_xloc.T, levels=contourf_levels, extend='both', cmap='viridis') ax.contour(z - config.S / 2, y, wx_xloc.T, levels=contour_levels, linewidths=0.25, colors='black')
filepath = datadir / 'probe-p.h5' probe = petibmpy.ProbeVolume(name, name) (x, y), p = probe.read_hdf5(filepath, time) # Define circle outside support region of delta function. dx = 1.5 / 90 # grid-spacing in the uniform region R = 0.5 + 3 * dx # radius 3 cells away from real boundary nb = 100 theta = numpy.linspace(0.0, 2 * numpy.pi, num=nb + 1)[:-1] xc, yc = 0.0, 0.0 xb, yb = xc + R * numpy.cos(theta), yc + R * numpy.sin(theta) # Interpolate the field on extended boundary. pb = numpy.empty_like(xb) for i, (xbi, ybi) in enumerate(zip(xb, yb)): pi = petibmpy.linear_interpolation(p, y, ybi) pb[i] = petibmpy.linear_interpolation(pi, x, xbi) # Compute the pressure coefficient. rho = 1.0 # fluid density U_inf = 1.0 # freestream speed p_inf = 0.0 # far-away pressure cp = (pb - p_inf) / (0.5 * rho * U_inf**2) # Re-arrange values to split apart lower and upper surfaces. cp_lower = numpy.append(cp[nb // 2:], [cp[-1]]) theta_lower = numpy.linspace(0.0, 180.0, num=cp_lower.size) cp_upper = cp[:nb // 2 + 1][::-1] theta_upper = numpy.linspace(0.0, 180.0, num=cp_upper.size) # Load digitized values from Li et al. (2016).
pyplot.rc('font', family='serif', size=12) nrows, ncols = 3, 2 fig, ax = pyplot.subplots(nrows=nrows, ncols=ncols, figsize=(10.0, 10.0)) phases = [180, 210, 330] # phase angles (in degrees) times = [17.5, 17.916, 19.584] # corresponding time units x_locs = [-0.6, 0.0, 0.6, 1.2] # cross-section locations for row in range(nrows): for col in range(ncols): name = 'u' if col == 0 else 'v' time, phase = times[row], phases[row] filepath = datadir / f'probe{phase}-{name}.h5' for xi in x_locs: probe = petibmpy.ProbeVolume(name, name) (x, y), u = probe.read_hdf5(filepath, time) ui = petibmpy.linear_interpolation(u.T, x, xi) ax[row, col].plot(ui / Um, y / D, label=f'{xi}') ax[row, col].set_xlabel('$u / U_m$' if col == 0 else '$v / U_m$') ax[row, col].set_ylabel('$y / D$') ax[row, col].set_xlim(-1.5, 1.5) ax[row, col].set_ylim(-1.1, 1.1) ax[row, col].text(0.7, 0.8, r'$\phi = {}^o$'.format(phases[row])) ax[0, 1].legend(title='$x/D$', loc='center left', prop={'size': 12}, frameon=False) fig.tight_layout() # Save the figure. figdir = simudir / 'figures' figdir.mkdir(parents=True, exist_ok=True) filepath = figdir / 'velocity_profiles.png' fig.savefig(filepath, dpi=300, bbox_inches='tight')