How to fix the issue of plotting a 2D sine wave in python-CodePudding

I want to generate 2D travelling sine wave. To do this, I've set the parameters for the plane wave and generate wave for any time instants like as follows:

import numpy as np
import random
import matplotlib.pyplot as plt
f = 10         # frequency
fs = 100       # sample frequency
Ts = 1/fs      # sample period
t = np.arange(0,0.5, Ts)   # time index
c = 50             # speed of wave
w = 2*np.pi *f     # angular frequency
k = w/c            # wave number

resolution = 0.02
x = np.arange(-5, 5, resolution)
y = np.arange(-5, 5, resolution)
dx = np.array(x); M = len(dx)
dy = np.array(y); N = len(dy)
[xx, yy] = np.meshgrid(x, y);
theta = np.pi / 4         # direction of propagation
kx =  k* np.cos(theta)
ky = k * np.sin(theta)

So, the plane wave would be

plane_wave = np.sin(kx * xx   ky * yy - w * t[1])
plt.figure(); 
plt.imshow(plane_wave,cmap='seismic',origin='lower', aspect='auto')

that gives a smooth plane wave as shown in . Also, the sine wave variation with plt.figure(); plt.plot(plane_wave[2,:]) time is given in . However, when I want to append plane waves at different time instants then there is some discontinuity arises in figure 03 & 04 , and I want to get rid of from this problem.

I'm new in python and any help will be highly appreciated. Thanks in advance.

arr = []
for count in range(len(t)):
    p = np.sin(kx * xx   ky * yy - w * t[count]); # plane wave
    arr.append(p)
arr = np.array(arr)
print(arr.shape)
pp,q,r = arr.shape
sig = np.reshape(arr, (-1, r))
print('The signal shape is :', sig.shape)

plt.figure(); plt.imshow(sig.transpose(),cmap='seismic',origin='lower', aspect='auto')
plt.xlabel('X'); plt.ylabel('Y')
plt.figure(); plt.plot(sig[2,:])

CodePudding user response：

This is not that much a problem of programming. It has to do more with the fact that you are using the physical quantities in a somewhat unusual way. Your plots are absolutely fine and correct.

What you seem to have misunderstood is the fact that you are talking about a 2D problem with a third dimension added for time. This is by no means wrong but if you try to append the snapshot of the 2D wave side-by-side you are using (again) the x spatial dimension to represent temporal variations. This leads to an inconsistency of the use of that coordinate axis. Now, to make this more intuitive, consider the two time instances separately. Does it not coincide with your intuition that all points on the 2D plane must have different amplitudes (unless of course the time has progressed by a multiple of the period of the wave)? This is the case indeed. Thus, when you try to append the two snapshots, a discontinuity is exhibited. In order to avoid that you have to either use a time step equal to one period, which I believe is of no practical use, or a constant time step that will make the phase of the wave on the left border of the image in the current time equal to the phase of the wave on the right border of the image in the previous time step. Yet, this will always be a constant time step, alternating the phase (on the edges of the image) between the two said values.

The same applies to the 1D case because you use the two coordinate axes to represent the wave (x is the x spatial dimension and y is used to represent the amplitude). This is what can be seen in your last plot.

Now, what would be the solution you may ask. The solution is provided by simple inspection of the mathematical formula of the wave function. In 2D, it is a scalar function of three variables (that is, takes as input three values and outputs one) and so you need at least four dimensions to represent it. Alas, we can't perceive a fourth spatial dimension, but this is not a problem in your case as the output of the function is represented with colors. Then there are three dimensions that could be used to represent the temporal evolution of your function. All you have to do is to create a 3D array where the third dimension represents time and all 2D snapshots will be stored in the first two dimensions.

When it comes to visual representation of the results you could either use some kind of waterfall plots where the z-axis will represent time or utilise the fourth dimension we can perceive, time that is, to create an animation of the evolution of the wave.

I am not very familiar with Python so I will only provide a generic naive implementation. I am sure a lot of people here could provide some simplification and/or optimisation of the following snippet. I assume that everything in your first two blocks of code is available so changes have to be done only in the last block you present

arr = np.zeros(len(xx), len(yy), len(t)) # Initialise the array to hold the temporal evolution of the snapshots

for i in range(len(t)):
    arr[:, :, i] = np.sin(kx * xx   ky * yy - w * t[i])

# Below you can plot the figures with any function you prefer or make an animation out of it