This example shows you how to model and simulate the output of active and passive radar sensors. In this example, you observe how radio frequency (RF) interference impacts the detection performance of a radar. In addition, you use passive radar sensors to estimate the location and type of the RF interference.

### Introduction

Assessing tracking performance for radars requires modeling a radio frequency (RF) scenario. This includes:

• Generating RF emissions

• Propagating the emissions and reflecting these emissions from platforms

• Receiving the emissions, calculating interference losses, and generating detections

### Create scenario

This example shows you how to perform each of the steps above using a scenario consisting of three platforms:

1. Airborne platform flying north at 500 km/h from the bottom of the scenario

2. Airborne platform flying south at 600 km/h from the top of the scenario

3. Airborne platform flying east at 700 km/h in the middle of the scenario

```% Create a tracking scenario to manage the movement of the platforms. scene = trackingScenario; % Set the duration of the scenario to 10 seconds. scene.StopTime = 10; % s % Platform 1: Airborne and northbound at 500 km/h spd = 500*1e3/3600; % m/s wp1 = [0 0 -6000]; wp2 = [spd*scene.StopTime 0 -6000]; toa = [0; scene.StopTime]; platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa)); % Platform 2: Airborne and southbound at 600 km/h spd = 600*1e3/3600; % m/s wp1 = [30e3+spd*scene.StopTime 0 -6000]; wp2 = [30e3 0 -6000]; toa = [0; scene.StopTime]; platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa)); % Platform 3: Airborne and eastbound at 700 km/h spd = 700*1e3/3600; % m/s wp1 = [10e3 1e3 -6000]; wp2 = [10e3 1e3+spd*scene.StopTime -6000]; toa = [0; scene.StopTime]; platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa));```

Use `theaterPlot` to create a display showing the platforms in the scenario and their trajectories.

```ax = axes; theaterDisplay = theaterPlot('Parent',ax,'AxesUnit',["km" "km" "km"], 'XLim',[-10000 40000] , 'YLim', [-20000 20000], 'ZLim',[-1e7 1e7]); view([90 -90]) % swap X and Y axis patch('XData',[-10000 -10000 40000 40000],'YData',[-20000 20000 20000 -20000],'EdgeColor','none', 'FaceColor',[0.8 0.8 0.8],'DisplayName','Ground'); platPlotter = platformPlotter(theaterDisplay,'DisplayName','Platforms','MarkerFaceColor','k'); plotPlatform(platPlotter,vertcat(scene.platformPoses.Position)); trajPlotter = trajectoryPlotter(theaterDisplay,'DisplayName','Trajectories','LineStyle','-'); allTrajectories = cellfun(@(x) x.Trajectory.lookupPose(linspace(0,scene.StopTime,10)), scene.Platforms, 'UniformOutput', false); plotTrajectory(trajPlotter,allTrajectories);```

### Radar Detection in the Presence of Interfering Emissions

Often, a radar operates in an environment where other undesirable RF emissions interfere with the waveforms emitted by the radar. When this occurs, the radar will experience a degradation in detection performance in the direction of the interfering signals. Attach an RF emitter to the platform at the bottom of the scenario (the first platform) and a radar to the platform at the top of the scenario (the second platform).

Create an RF emitter

Model an RF emission using a `radarEmitter`. The emitter is in a forward-looking configuration with an azimuthal field of view of 20 degrees to include the 2 other platforms in the scenario. The effective isotropic radiated power (EIRP) sets the strength of the interfering signal. The waveform type is a user-defined value used to enumerate the various waveform types that are present in the scenario. For this scenario, use the value 0 to indicate a noise waveform type.

```% Create the interference emitter. rfEmitter = radarEmitter(1, 'No scanning', ... 'FieldOfView', [20 5], ... % [az el] deg 'EIRP', 200, ... % dBi 'CenterFrequency', 300e6, ... % Hz 'Bandwidth', 30e6, ... % Hz 'WaveformType', 0) % Use 0 for noise-like emissions```
```rfEmitter = radarEmitter with properties: EmitterIndex: 1 UpdateRate: 1 ScanMode: 'No scanning' MountingLocation: [0 0 0] MountingAngles: [0 0 0] FieldOfView: [2×1 double] MechanicalAngle: 0 LookAngle: 0 HasElevation: 0 EIRP: 200 CenterFrequency: 300000000 Bandwidth: 30000000 WaveformType: 0 ProcessingGain: 0 ```

Attach the emitter to the first platform.

```platEmit = scene.Platforms{1}; platEmit.Emitters = rfEmitter```
```platEmit = Platform with properties: PlatformID: 1 ClassID: 0 Dimensions: [1×1 struct] Trajectory: [1×1 waypointTrajectory] PoseEstimator: [1×1 insSensor] Emitters: {[1×1 radarEmitter]} Sensors: {} Signatures: {[1×1 rcsSignature] [1×1 irSignature] [1×1 tsSignature]} ```

Equip the second platform with a monostatic radar. Use `monostaticRadarSensor` to model this type of radar. Configure the radar to scan the azimuth sector in front of its platform which includes the other platforms.

```% Create a monostatic radar. radar = monostaticRadarSensor(2, 'Sector', ... 'UpdateRate', 12.5, ... % Hz 'FieldOfView', [2 10]); % [az el] deg % Mount the radar so that it scans the sector in front of the second % platform which includes the interfering signal and the third platform. radar.MountingAngles = [0 0 0]; % [Z Y X] deg % Enable the radar's INS input so that it can use the pose estimated by % the platform's pose estimator to generate detections. radar.HasINS = true; % Enable the radar's interference input so that the interference signal % created by the emitter above can be passed to the radar. radar.HasInterference = true; % Set coordinate system for detections to scenario radar.DetectionCoordinates = 'scenario'```
```radar = monostaticRadarSensor with properties: SensorIndex: 2 UpdateRate: 12.5000 ScanMode: 'Mechanical' MountingLocation: [0 0 0] MountingAngles: [0 0 0] MaxUnambiguousRange: 100000 MaxUnambiguousRadialSpeed: 200 FieldOfView: [2×1 double] MaxMechanicalScanRate: 75 MechanicalScanLimits: [-45 45] MechanicalAngle: 0 LookAngle: 0 DetectionProbability: 0.9000 FalseAlarmRate: 1.0000e-06 Show all properties ```
```% Attach the radar to the second platform. platRadar = scene.Platforms{2}; platRadar.Sensors = radar;```

Update the display to show the platforms, the radar, and the emitter in the scenario.

```emitterColor = [0.9290 0.6940 0.1250]; radarColor = [0 0.4470 0.7410]; platEmitPlotter = platformPlotter(theaterDisplay,'DisplayName', 'RF emitter','Marker','d','MarkerFaceColor',emitterColor); platRadarPlotter = platformPlotter(theaterDisplay,'DisplayName','Monostatic radar','Marker','d','MarkerFaceColor',radarColor); platPlotter.DisplayName = 'Targets'; clearData(platPlotter); covPlotter = coveragePlotter(theaterDisplay,'Alpha',[0.2 0]); detPlotter = detectionPlotter(theaterDisplay,'DisplayName','Radar detections','MarkerFaceColor',radarColor); title('Radar detection with an interfering emitter'); plotPlatform(platRadarPlotter, platRadar.pose.Position); plotPlatform(platEmitPlotter, platEmit.pose.Position); plotPlatform(platPlotter, scene.Platforms{3}.pose.Position); plotCoverage(covPlotter, coverageConfig(scene), [-1 2], {emitterColor, radarColor});```

In the preceding figure, the platform carrying the forward-looking radar is shown as a blue diamond, with the radar's current field of view as a blue region originating from the platform. At the bottom of the figure, the platform carrying the interfering RF emission is shown as a yellow diamond, with the emitter's current field of view shown as a corresponding yellow region. Platforms without any emitters or sensors attached to them are referred to as targets and are displayed as black triangles.

Simulate monostatic detections

In multi-rate scenarios, you can either find an update rate that is a common divider of all the sensors and emitters rates defined in the scenario or you can use the continuous update which will automatically advance the scenario to the next valid update time when calling `advance`.

`scene.UpdateRate = 0`
```scene = trackingScenario with properties: UpdateRate: 0 StopTime: 10 SimulationTime: 0 IsRunning: 1 Platforms: {[1×1 fusion.scenario.Platform] [1×1 fusion.scenario.Platform] [1×1 fusion.scenario.Platform]} ```

For each step in the following loop use:

1. `advance` to move all of the platforms according to their trajectories.

2. `emit` to update the emissions transmit direction from `platEmit`.

3. `propagate` to propagate the emissions directly to each platform in the scenario that lies within the emitter's field of view. Each platform that receives a direct path emission generates a single-bounce reflection that is also propagated to every other platform as a reflected emission.

4. `detect` to generate detections from the emissions received at `platRadar`.

This propagation of the emitter's emissions from the emitter to the radar sensor are illustrated in the following image.

```% Set the random seed for repeatable results. rng(2018); plotDets = {}; while advance(scene) % Emit the RF signal. txEmiss = emit(scene); % Reflect the emitted signal off of the platforms in the scenario. reflEmiss = propagate(scene, txEmiss); % Generate detections from the monostatic radar sensor. [dets, config] = detect(scene, reflEmiss); % Reset detections every time the radar completes a sector scan. if config.IsScanDone % Reset plotDets = dets; else % Buffer plotDets = [plotDets;dets]; %#ok<AGROW> end % Update display with current platform positions, beam positions and detections. plotPlatform(platRadarPlotter, platRadar.pose.Position); plotPlatform(platEmitPlotter, platEmit.pose.Position); plotPlatform(platPlotter, scene.Platforms{3}.pose.Position); plotCoverage(covPlotter, coverageConfig(scene), [-1 2], {emitterColor, radarColor}); if ~isempty(plotDets) allDets = [plotDets{:}]; % extract column vector of measurement positions meas = [allDets.Measurement]'; plotDetection(detPlotter,meas); end end```

As shown in the preceding figure, the radar (shown in blue) is only able to detect the target in the middle of the scenario. The detections are shown as blue, filled circles, and are made whenever the radar's field of view (e.g. beam) sweeps across the target. However, when the radar's beam sweeps across the emitting platform (shown in yellow), no detections are generated, since the interference generated by this platform prevents detection by the radar.

### Passive Detection of RF Emissions

In the preceding section, the radar was unable to detect the location of the emitting platform because the emissions from that platform masked the radar's own emissions. However, such strong emissions can be detected and identified by passive sensors which listen for RF emissions in the scenario. These sensors are often referred to as electronic support measures (ESM). These sensors typically listen across a broad range of frequencies and attempt to identify unique emitters, the direction of arrival of the emissions from those emitters, and whenever possible, the type of waveform used by the emitter.

Create an ESM sensor

Reuse the scenario from the previous section, but replace the monostatic radar on the first platform with an ESM sensor. Use `radarSensor` to model the ESM sensor and ensure that the sensor is configured so that its center frequency and bandwidth includes the RF spectrum of the emitter. Otherwise, it will be unable able to detect the emitter.

```restart(scene); esm = radarSensor(1, 'No scanning', ... 'DetectionMode', 'ESM', ... 'UpdateRate', 12.5, ... % Hz 'MountingAngles', [0 0 0], ... % [Z Y X] deg 'FieldOfView', [30 10], ... % [az el] deg 'CenterFrequency', 300e6, ... % Hz 'Bandwidth', 30e6, ... % Hz 'WaveformTypes', 0, ... % Detect the interference waveform type 'HasINS', true)```
```esm = radarSensor with properties: SensorIndex: 1 UpdateRate: 12.5000 ScanMode: 'No scanning' DetectionMode: 'ESM' MountingLocation: [0 0 0] MountingAngles: [0 0 0] FieldOfView: [2×1 double] MechanicalAngle: 0 LookAngle: 0 Sensitivity: -50 FalseAlarmRate: 1.0000e-06 Show all properties ```

Replace the radar on the second platform with the ESM sensor.

```platESM = scene.Platforms{2}; platESM.Sensors = esm;```

Update the visualization accordingly

```platRadarPlotter.DisplayName = "ESM sensor"; esmColor = [0.4940 0.1840 0.5560]; platRadarPlotter.MarkerFaceColor = esmColor; % use a helper to add an angle only detection plotter delete(detPlotter); esmDetPlotter = helperAngleOnlyDetectionPlotter(theaterDisplay,'DisplayName','ESM detections','Color',esmColor,'LineStyle','-'); clearData(covPlotter); plotCoverage(covPlotter, coverageConfig(scene), [-1 1], {emitterColor, esmColor}); title('Passive detection of RF emissions');```

In the preceding figure, the radar is replaced by an ESM sensor mounted on the second platform. The ESM sensor's field of view is shown in magenta and includes both the emitting and target platforms.

Simulate ESM detections

Now simulate detections using the ESM sensor instead of the radar. You will notice that because the ESM sensor is a passive sensor, it is unable to localize the emitting platform, but indicates the direction of arrival the platform's emissions. These angle-only detections are shown as rays originating from the ESM sensor towards the emitting platform.

```% Set the random seed for repeatable results. rng(2018); plotDets = {}; snap = []; while advance(scene) % Emit the RF signal. txEmiss = emit(scene); % Reflect the emitted signal off of the platforms in the scenario. reflEmiss = propagate(scene, txEmiss); % Generate detections from the monostatic radar sensor. [dets, config] = detect(scene, reflEmiss); % Reset detections every time the radar completes a sector scan. if config.IsScanDone % Reset plotDets = dets; else % Buffer plotDets = [plotDets;dets]; %#ok<AGROW> end % Update display with current platform positions, beam positions and detections. plotPlatform(platRadarPlotter, platRadar.pose.Position); plotPlatform(platEmitPlotter, platEmit.pose.Position); plotPlatform(platPlotter, scene.Platforms{3}.pose.Position); plotCoverage(covPlotter, coverageConfig(scene), [-1 1], {emitterColor, esmColor}); plotDetection(esmDetPlotter,plotDets); % Record the reflected detection at t = 2 sec snap = getSnap(ax, scene.SimulationTime, 2, snap); drawnow end title('RF emitter detected by an ESM sensor');```

The RF emissions are detected and their direction of arrival is estimated by the ESM sensor. This is shown by the magenta line originating from the sensor and closely passing by the emitter. There is some noise in the estimated angle, which is why the line does not pass directly through the emitter's location.

The ESM sensor classifies the waveform types in its reported detections. For this emitter, it reports the noise waveform type used by the emitter: 0.

`dets{1}.ObjectAttributes{1}`
```ans = struct with fields: TargetIndex: 1 EmitterIndex: 1 WaveformType: 0 SNR: 184.8224 ```

Notice that the signal-to-noise ratio (SNR) of the emitted signal detected by the sensor is very large, 185 dB. Because the RF emitter has high power, reflections of the emitted waveform off of the target will also be detected by the ESM sensor. This is seen at 2 seconds in the simulation when the target lies within the emitter's field of view.

```figure; imshow(snap.cdata); title('Emitter and target detected by an ESM sensor');```

In the preceding figure, emissions are detected from both the emitter and the target, as the target receives energy from the emitter and re-emits that waveform back into the scenario, causing it to be detected by the ESM sensor as well.

### Passive Detection of Monostatic Radars

Monostatic radars also emit waveforms into the scenario. Sometimes it is desirable to be able to detect their emissions. To do this, you must model both the emitting and sensing portions of the radar separately. The emitter generates the waveforms which become part of the scenario's RF emissions. These waveforms can then be detected by other sensors, such as the ESM sensor presented in the preceding section.

Reuse the same scenario from the preceding sections. For this scenario, attach a monostatic radar to the platform at the top of the scenario (the second platform), and attach an ESM sensor to the platform at the bottom of the scenario (the first platform). The middle platform remains a target with no emitters or sensors attached to it.

`restart(scene);`

Create a monostatic radar by modeling both the emitting and sensing portions of the sensor. Use `radarEmitter` to model the monostatic radar emitter. For this scenario, use 1 to indicate the waveform type used by this radar, where perhaps 1 represents an LFM chirp with some predefined parameters. The waveform type is an enumeration defined by the user to represent the different kinds of waveforms simulated in the scenario. This enables emitters and sensors to know how to process these waveforms to generate detections. For example, if an emitter has a waveform type of 1 and a sensor includes this type in its waveform list, then the sensor will know how to process the emitter's emissions (e.g. using a matched filter) and will detect the emission and realize the processing gain associated with that waveform.

```% Create the emitter for the monostatic radar. radarTx = radarEmitter(2, 'Sector', ... 'UpdateRate', 12.5, ... % Hz 'MountingAngles', [0 0 0], ... % [Z Y X] deg 'FieldOfView', [2 10], ... % [az el] deg 'CenterFrequency', 300e6, ... % Hz 'Bandwidth', 3e6, ... % Hz 'ProcessingGain', 50, ... % dB 'WaveformType', 1) % Use 1 to indicate this radar's waveform```
```radarTx = radarEmitter with properties: EmitterIndex: 2 UpdateRate: 12.5000 ScanMode: 'Mechanical' MountingLocation: [0 0 0] MountingAngles: [0 0 0] FieldOfView: [2×1 double] MaxMechanicalScanRate: 75 MechanicalScanLimits: [-45 45] MechanicalAngle: 0 LookAngle: 0 HasElevation: 0 EIRP: 100 CenterFrequency: 300000000 Bandwidth: 3000000 WaveformType: 1 ProcessingGain: 50 ```

Use `radarSensor` to model the sensing portion of the radar which receives the RF emissions in the scenario, identifies the emissions that corresponds to the monostatic emitter's waveform type, and generates detections from these received emissions. Emissions which do not match the emitter's waveform type are treated as interference.

When using `radarSensor` to model the sensing portion of a monostatic radar, you must set the `DetectionMode` property of the sensor to `Monostatic`. This tells the sensor to use the emitter's configuration when processing the received RF emissions.

```radarRx = radarSensor(2, ... 'DetectionMode', 'Monostatic', ... 'EmitterIndex', radarTx.EmitterIndex, ... 'HasINS', true,... 'DetectionCoordinates','Scenario')```
```radarRx = radarSensor with properties: SensorIndex: 2 DetectionMode: 'Monostatic' EmitterIndex: 2 MaxUnambiguousRange: 100000 MaxUnambiguousRadialSpeed: 200 LookAngle: 0 Sensitivity: -50 FalseAlarmRate: 1.0000e-06 Show all properties ```
```% Attach to the radar emitter and sensor to the second platform. platRadar = scene.Platforms{2}; platRadar.Emitters = radarTx; platRadar.Sensors = radarRx;```

Reuse the ESM sensor from the preceding section, but set the list of known waveform types for the ESM sensor to include the waveform emitted by the radar. If the radar's waveform type is not known to the ESM sensor, it will not be detected.

```% Add the radar's waveform to the list of known waveform types for the ESM sensor. esm.WaveformTypes = [0 1]; % Attach the ESM sensor to the first platform. platESM = scene.Platforms{1}; platESM.Emitters = {}; % Remove the emitter. platESM.Sensors = esm; ```

Update the display to show both monostatic detections and esm detections.

```detPlotter = detectionPlotter(theaterDisplay,'DisplayName','Radar detections','MarkerFaceColor',radarColor); platRadarPlotter.DisplayName = 'Monostatic radar'; platRadarPlotter.MarkerFaceColor = radarColor; platEmitPlotter.DisplayName = 'ESM sensor'; platEmitPlotter.MarkerFaceColor = esmColor; clearData(esmDetPlotter); clearData(covPlotter); covcon = coverageConfig(scene); plotCoverage(covPlotter, covcon([1 3]) , [1 -2], {esmColor, radarColor}); title(ax,'Passive detection of a monostatic radar');```

In the preceding figure, the radar is scanning an azimuth sector in front of its platform which includes both the target platform as well as the platform carrying the ESM sensor. The radar will generate detections for both of these platforms when its field of view (shown in blue) sweeps over their location. However, when the radar's beam passes over the location of the ESM sensor, the ESM sensor will detect the radar and will indicate its estimated position by drawing a line originating from the sensor's location.

```% Set the random seed for repeatable results. rng(2018); platforms = scene.Platforms; numPlat = numel(platforms); plotDets = {}; snap = []; while advance(scene) % Emit the RF signal. [txEmiss, txConfigs] = emit(scene); % Reflect the emitted signal off of the platforms in the scenario. reflEmiss = propagate(scene, txEmiss); % Generate detections from the monostatic radar sensor. [dets, config] = detect(scene, reflEmiss, txConfigs); % Reset detections every time the radar completes a sector scan. if txConfigs(end).IsScanDone % Reset plotDets = dets; else % Buffer plotDets = [plotDets;dets];%#ok<AGROW> end % Update display with current platform positions, beam positions and detections. plotPlatform(platRadarPlotter, platRadar.pose.Position); plotPlatform(platEmitPlotter, platEmit.pose.Position); plotPlatform(platPlotter, scene.Platforms{3}.pose.Position); covcon = coverageConfig(scene); plotCoverage(covPlotter, covcon([1 3]) , [1 -2], {esmColor, radarColor}); plotDetection(esmDetPlotter,plotDets); plotMonostaticDetection(detPlotter,plotDets); % Record the reflected detection at t = 5.6 sec snap = getSnap(ax, scene.SimulationTime, 5.6, snap); drawnow end```

Detections from the monostatic radar modeled using `radarEmitter` and `radarSensor` are shown as filled, blue circles near the target and the platform equipped with the ESM sensor. The ESM sensor is also able to detect the radar, as is indicated by the angle-only detection shown as a line originating from the ESM sensor and passing near the radar platform.

```figure; imshow(snap.cdata); title('Radar and target detected by an ESM sensor');```

Because of the high power (EIRP) of the radar's emissions, the emitted energy is reflected off of the target towards the ESM platform as well. This results in the ESM sensor detecting the target platform at times when the radar emitter's field of view sweeps past the target platform when the target is still inside of the ESM sensor's field of view.

### Summary

In this example, you learned how to simulate the impact of RF interference on a monostatic radar. You also learned how to simulate passive sensors which can detect these interference sources as well as the radar sensors in the scenario.

### Supporting Functions

`getSnap` Records a snapshot of an axis at a given snap time.

```function snap = getSnap(hAx, curTime, snapTime, prevSnap) if ~isempty(prevSnap) snap = prevSnap; elseif curTime >= snapTime && curTime < snapTime + 0.05 hAx.Title.Visible = 'off'; snap = getframe(hAx.Parent); hAx.Title.Visible = 'on'; else snap = []; end end```

`plotMonostaticDetection` Parses detections to plot only monostatic detections with a `detectionPlotter.`

```function plotMonostaticDetection(plotter, dets) if ~isempty(dets) % Pass only monostatic detections to the detectionPlotter radarDetId = cellfun(@(x) x.SensorIndex == 2, dets); if any(radarDetId) % extract measurement positions for the monostatic radar radarDets = [dets{radarDetId}]; meas = [radarDets.Measurement]'; plotDetection(plotter,meas); end end end```

평가판 신청