Range-Lag Ambiguity Function toolbox

By Tom Grydeland <Tom.Grydeland@gmail.com>

When called without arguments, these functions will show help text for themselves. When called with the minimum number of arguments (interval sequence for multipulse codes, number of bauds or complete code set for alternating codes), they will create a plot in the current axis showing the range-lag ambiguity functions (W_t,t' in the notation used by Lehtinen [1986], called Wtt' in the following) for a given modulation. Where arguments are not given or given as an empty matrix, default values will be used instead. For Barker code functions, the length of the Barker code can be specified, defaulting to 13. (bc_wtt requires the length of the code to be specified.) The baud length can be specified, defaulting to 3 for Barker coded modulations and 20 for all others. All functions accept a lag argument, specifying for which lags (in units of bauds) range-lag ambiguity functions are computed.

For the ac_wgate_wtt function, the next argument can be used to specify a vector of weights, one for each scan of the code.

The next argument for each function can be used to specify in what axis to draw the plot, e.g. for use in multi-panel plots. If this argument is empty, (and plotfunction argument is not given, see below) the range-lag ambiguity function is returned (range along the vertical (first) dimension and lag along the horizontal (second) dimension) and no plots are made.

After the axis argument, the name of a 3-D plotting function can be given. This function must accept arguments (X, Y, Z) where X and Y are vectors, and size(Z) == [ length(X) length(Y) ]. Possible plotting functions are surf, contour, image, pcolor and variants thereof.

Any remaining arguments will be passed to the plot function after the X, Y, Z arguments

If a plot is made and an output argument is specified, the handle to the plot is returned.

For alternating codes (random or otherwise), each non-zero lag can be decoded in multiple ways, with different range contributions. The ac_lp_wtt and bcac_lp_wtt functions show a separate ambiguity function for each decoding possibility, corresponding to [Nygrén, 1996, figure 6.6]. To an experimenter trying to interpret a set of measurements from an incomplete code set, it is more interesting to know what range-lag ambiguity to expect in a single range gate from a partially decoded or small random code set. The functions ac_gate_wtt and bcac_gate_wtt average the ambiguity functions for all possible decodings of the desired lags, shifted such that the expected peaks coincide. The range axis of the plot is centered at the center range of the gate. The ac_wgate_wtt function does the same, but allowing for different weights for each code in the set.

For long pulses, the functions lp_lp_wtt and lp_lph_wtt shows the range-lag ambiguity functions of the different lagged products that can be formed, the latter using an arbitrary receiver impulse response. When creating range-gated autocorrelation functions (ACFs) from long pulse data, it is customary to average a number of lagged products, different for each lag, to form a range gate. The function lp_gate_wtt (not implemented yet) shows the range-lag ambiguity functions for the different lags of such a range gate, centered at the nominal center range of the gate.

The variants named *_lph_wtt accept a bandwidth/filter argument, which either specifies the bandwidth of a Butterworth filter (which uses the but_filt function from GUISDAP), or an arbitrary impulse response function. Bandwidth is specified in units of kHz assuming that the time unit is one μs. The programs make no attempt to determine whether the given bandwidths or impulse responses are meaningful.

Long pulse plots

lp_lp_wtt - Wtt' for a long pulse
lp_lph_wtt - as above, but using an arbitrary filter impulse response

Alternating code plots

ac_lp_wtt - Wtt' for an alternating code set
ac_gate_wtt - as above, but for a completely decoded range gate
ac_wgate_wtt - as above, but allowing for differently weighted pulses
ac_lph_wtt - Wtt' for an alternating code set, using an arbitrary filter impulse response

Barker codes

bc_wtt - Wtt' for a Barker code

Barker coded alternating code plots

bcac_lp_wtt - Wtt' for a Barker coded alternating code set
bcac_gate_wtt as above, but for a completely decoded range gate

Multipulse code plots

mp_lp_wtt - Wtt' for a multipulse code
bcmp_lp_wtt - Wtt' for a Barker coded multipulse code

Random codes

sign(randn(N, M)) generates a random code set with N scans of M bauds each, suitable as the codeset parameter to any of the alternating code plotting functions above

Supporting functions

multipulse - converts an interval sequence to a multipulse code
tau0code - generates the alternating code set for the tau0 experiment
altcode - generates strong alternating code sets of arbitrary size
barkercode - generates Barker codes of all known lengths
baudexpand - expands a sign sequence to patterns or bauds of given length
convolve - convolves its inputs along rows
walsh - generates the Walsh matrix from which strong codes are drawn
Contents - Table of contents for directory and short version of this text

Download tarball

wtt.tar - all files in a tar archive

Details of the programming

In the code, the unit of time (used for both lag and range) is not specified, but for practical purposes, it can be assumed to be one μs.

The functions do not assume "correctness" or "completeness" of codes or code sets, and will happily accept incomplete or random alternating code sets (indeed this was part of the motivation for writing the functions in the first place), and it will also accept codes that aren't Barker codes as the Barker code argument. This can be used to demonstrate imperfect cancellation of sidelobes and other range and/or lag ambiguities.

Near the top of each function, after argument processing, the transmission envelope env and receiver impulse response h are constructed. For the *_lp_wtt functions, h is given as a boxcar filter equal to the elementary baud in the code, while the *_lph_wtt functions allow for more realistic filters, as described above. From env and h, the amplitude ambiguity function (W^A_t(u; τ)) is computed [Lehtinen, 1986, eq. (2.10)]. In the functions, this is the variable wta, or cwta{jj} for alternating codes.

From the amplitude ambiguity function, the two-dimensional range-lag ambiguity functions (W_t,t'(τ, S)) for any given lag can be constructed, as a convolution along the delay dimension of the amplitude ambiguity function and a displaced (in the range direction) copy of the same. [Lehtinen, 1986, eq. (2.12)]. In the functions, these two-dimensional ambiguity functions for all desired lags are combined into the variable wtt. When different ambiguity functions overlap (as they often do), the maximum non-zero value is used. Particularly in coding schemes subcoded by a Barker code, this leads to apparent asymmetries that may not be present in the individual ambiguity functions.

For alternating codes, the two-dimensional ambiguity functions for any given scan in the code set is ambiguous in range, only when the code set is decoded are these ambiguities reduced or, (for complete sets of Lehtinen-type alternating codes), eliminated. Furthermore, each lag can be decoded in multiple ways, yielding different (more or less unambiguous) range contributions. In these cases, decoding is done in the temporary variable wtmp and only after decoding is the resulting ambiguity function incorporated into wtt.

The decoding coefficients are computed from the code set, a procedure which works equally well for all kinds of alternating codes.

Examples

Retrieving the amplitude ambiguity function is not provided for, but should be simple enough to read from the code. Follow the link in each example to see the plot made from that particular instruction.

The axes have been made equal using axis image in every plot.

The two-dimensional ambiguity function in Figure 2.2 from Lehtinen [1986] can be created with the command
```
    mp_lp_wtt([1 1.5], [], 1)
```
where [1, 1.5] are the gaps in this (ambiguous) code and 1 is the lag being considered.
The two-dimensional counterparts to the reduced ambiguity functions in Figure 2.3 from Lehtinen [1986] can be created with the commands
```
    mp_lp_wtt([.5 1.5 1], [], 0)
    mp_lp_wtt([.5 1.5 1], [], .5)
    mp_lp_wtt([.5 1.5 1], [], 1)
    mp_lp_wtt([.5 1.5 1], [], 2)
```
(from which we can conclude that the lags in this figure are mislabelled, which also applies to the identical figure 6 in Lehtinen and Huuskonen [1996].)
The two-dimensional ambiguity functions for a four-pulse multipulse given in figure 2 of Holt et al., [1992]:
```
    mp_lp_wtt([1 3 2])
```
Figure 4.4 of Nygrén [1996], 2-pulse code:
```
    mp_lp_wtt([1])
```
Figure 5.19 of Nygrén [1996], 13-bit Barker code:
```
    bc_wtt(13)
```
The two-dimensional ambiguity functions for a single-pulse modulation given in figure 5.30 of Nygrén [1996].
```
    lp_lp_wtt(5, 20)
```
Figure 3 of Holt et al., [1992] is quite similar, except that here, a more realistic filter impulse response (Butterworth, 50 kHz) is used.
```
    lp_lph_wtt(5, 20)
```
Figure 6.6 of Nygrén [1996], 4-bit strong alternating code set.
```
    ac_lp_wtt(4)
```
A 4-pulse multipulse code subcoded with a 7-bit Barker code
```
    bcmp_lp_wtt([1 3 2], 7)
```
The range-lag ambiguities of a decoded range gate using 12 scans, each comprising 8 randomly selected bauds
```
    ac_gate_wtt(sign(randn(8, 12)))
```
As above, for a complete 8-bit alternating code subcoded with a 7-bit Barker, showing complete cancellation of range ambiguities from the alternating code, although the range ambiguities due to the Barker code remain
```
    bcac_gate_wtt(8, 7)
```
Comparing range-lag ambiguities for Barker codes of different lengths (including a 28-bit Barker-like code)
```
    s=[3,7,13,28];for k=1:4,subplot(2,2,k),bc_wtt(s(k));end
```
Demonstrating (perhaps surprising) range ambiguities in an otherwise valid 4-pulse modulation subcoded with a Barker code. The figure shows lags 0 (obviously ambiguous), 2 and 4. These are 2-dimensional versions of some of the range ambiguity functions in [Huuskonen et al., 1988, fig. 3].
```
    bcmp_lp_wtt([1 3 2], 13, [], [0 2 4])
```
Demonstrating really bad range and lag ambiguities resulting from subcoding a 4-bit alternating code with something which is obviously not a Barker code:
```
    bcac_lp_wtt(4, [1 -1 1 -1 1])
```

References

Holt, J. M., Rhoda, D. A., Tetenbaum, D., and van Eyken, A. p., Optimal analysis of incoherent scatter radar data, Radio Science 27, 435-447, (ADS), 1992.
Huuskonen, A., Pollari, p., Nygrén, T., and Lehtinen, M. S., Range ambiguity effects in Barker-coded multipulse experiments with incoherent scatter radars, J. Atmos. Terr. Phys., 50(4/5), 265--276, doi:10.1016/0021-9169(88)90013-X, (ADS), 1988.
Lehtinen, M. S., Statistical theory of Incoherent Scatter Radar measurements, Ph. D. Thesis, University of Helsinki, Helsinki, Finland, 1986.
Lehtinen, M. S. and A. Huuskonen., General incoherent scatter analysis and GUISDAP. J. Atmos. Terr. Phys., 58(1-4), 435-452, doi:10.1016/0021-9169(95)00047-X, (ADS), 1996.
Nygren, T. Introduction to Incoherent Scatter Measurements. Invers publications, Sodankylä, Finland, 1996.
Nygrén, T., Huuskonen, A., and Pollari, p., Alternating-coded multipulse codes for incoherent scatter experiments, J. Atmos. Terr. Phys., 58(1-4), 465-477, doi:10.1016/0021-9169(95)00049-6, (ADS), 1996.