Like many other geophysical operators, the inverse NMO stack operator can be coded in either ``push'' or ``pull'' forms, namely, we can loop over the output space and ``pull'' a corresponding value from the input space, or loop over the input space and ``push'' the value to an appropriate location in the output space. The adjoint of a pull operator is a push operator and vice versa, which I call implementation adjoint.

On the other hand, there is another scheme of implementing the geophysical forward and adjoint operation, which seems to be more reasonable. That is, using ``push'' in both the forward and adjoint operations. The reason I say it seems to be more reasonable is because it is a kind of energy-conserved scheme. For example, starting with a forward ``push'' operation, we push all the input energy into the output space, then we push the energy back into the input space by applying a adjoint ``push'' operation. Seemingly, there is no energy loss during the forward & adjoint operation, and we should be able to get the exact original input. Actually, since all the implementations are discrete schemes, some kind of interpolation is inevitable. The discrete adjoint ``push'' operation is not exact adjoint as it should be in the continuous space. Therefore, the output of adjoint operation will not be the same as the input.

I implement the inverse NMO stack operator using two interpolation methods, nearest-neighborhood interpolation and linear interpolation. If I implement the forward operation by ``push'' and the adjoint operation by ``pull'', or vice versa, the results are correct and independent of the interpolation scheme and the velocity type, as shown in Figure 1. In other words, if the geophysical forward and adjoint operation loop over the same space (model or data), the result will be acceptable.

Figure 1

Then I try to implement both the forward and adjoint operations using ``push'' or ``pull''. As shown in Figure 2, the results are unsatisfactory, no matter what interpolation and velocity I use. It means that, if the forward and adjoint operation loop over different spaces, we cannot recover the original input.

Figure 2

In seismic processing, we start with a CMP gather in the data space and want
to find the best-fit stack trace in the model space. Therefore, we only need
to think about the adjoint operation. In this case, I claim that the ``pull''
implementation is the only choice and the ``push'' implementation will give
an incorrect result.
Because in equation (1), we assume the RMS velocity is the
zero-offset velocity. The ``push'' scheme actually uses the RMS
velocity *v*(*t*) instead of .

Figure 3 shows a CMP gather and its estimated depth-variable
RMS velocity. Starting with this CMP gather, I try both the ``pull'' and
``push'' scheme to invert for the stack trace.
Figure 4 shows the results from the two schemes and also the
difference between the two schemes. The amplitude of the ``pull'' scheme
result is higher than that of the ``push'' scheme result. This means the
kinematic relation is better observed in the ``pull'' scheme. It is also very
clear that the difference becomes small in the deep zone. This is due to the
fact that the hyperbolic event becomes flatter with increasing time,
which makes *v*(*t*) similar to .

Figure 3

Figure 4

In order to verify the above conclusion, I compare the ``pull'' scheme result with the conventional NMO+stack result (Figure 5). The difference between these two approaches is negligible. This proves that the inverse NMO stack is equivalent to NMO + stacking.

Figure 5

11/11/1997