Final Project — B-21 Penetrating-Strike Route Planning#
Background#
Every block of the course built one piece of a mission plan: the radar range law and the layered air defense (Block 1), bearings, geolocation and jamming (Block 2), and a B-21 signature that changes with the aspect it presents (Block 3). Block 4 turns those pieces into survivability, and this project puts them on one map. A B-21 must penetrate an integrated air defense — an early-warning radar that cues the SAMs, a long-range SAM, three medium-range SAMs, and an infrared point defense at the target — strike the target, and come home on a fixed fuel load. You are the mission planner. You build the threat picture, turn the kill chain into a cost that Dijkstra can minimize, plan the route under the fuel limit, measure how well the adversary’s passive network can track you along it, decide what a stand-off jammer and one SEAD nomination buy, react to a pop-up SAM, and recommend the route to fly with the risk it leaves you.
The project is individual and stands in lieu of a final exam. You write it up as a journal article in IEEE format (4–5 pages), review two classmates’ drafts, and revise from the reviews you receive. The paper cites at least one course lesson from each block, each for a specific claim; outside sources are optional. An issued MATLAB toolkit, FPToolkit.m, carries the models, so your time goes to the decisions and to the paper. The handout carries the full rules, including what AI may and may not do for the code and for the paper.
Materials#
Final Project handout (PDF) — the authoritative tasking, models, deliverables, and rubric
FP_OrbitCandidates.csv — the five candidate stand-off jammer orbits for T5
B21_SignaturePattern.csv — the Project 3 B-21 signature vs aspect (VHF and X-band RCS, IR)
MATLAB bundle · L38_FinalProjectStarter.m↓
Final Project - Peer Review Form.pdf — the form for your two peer reviews (L39, and before L40)
How to use the template, what AI may do in the paper, and how to vet any outside sources for Appendix A — Source Vetting: L38 — Final Project Work Day. Sample AI prompts for each coding task are at the bottom of this page.
The toolkit code/FPToolkit.m and the starter code/L38_FinalProjectStarter.m are bundled in the course code download with all four CSVs beside them. The toolkit implements every model in the handout — signature, kill chain and hazard, lethal and jammed contours, the grid digraph, edge risk under a support plan, Dijkstra with the handout’s tie rule, route scoring, and both CRLBs — and makes no decisions: the weight, the fuel-limited choice, the support plan and the maneuver are yours. Type help FPToolkit for the method list and help FPToolkit.route (or any method) for its inputs, outputs and an example. The starter is a short tour: it loads the scenario, draws the laydown, plans one distance-only route, and scores it against one site.
Timeline#
All submissions and draft exchanges go through the course Teams team.
L31 — project issued. Each Block 4 lesson adds a layer: the survival metric (L31), the threat picture (L32), their track on you (L33), the route (L34), the pop-up (L35), the support package (L36), and the limitations (L37).
L35 — checkpoint (required, feedback only): a one-paragraph approach, a first T1 laydown figure built from the starter’s, and the four lessons you plan to cite (one per block) with the claim each will support.
L38 — work day.
L39 — complete draft (PDF) due at the start of class; peer review #1 in class.
Before the start of L40 — peer review #2 (PDF).
L40 — revision work day.
L41, start of class — final paper, response-to-reviewers table, code, and any AI transcripts, alongside HW4 and Quiz 4.
Late deliverables need coordination with the instructor at least 24 hours before the deadline; otherwise they receive a zero. The Final Project has no innovation bonus — it is graded on the rubric in the handout.
Getting coding help from AI — sample prompts#
Each prompt follows the handout’s Use of AI rules. You state your own approach first; you paste the toolkit’s help text, so the AI calls the toolkit instead of inventing its own models; you ask for code that does exactly your approach; and you ask the AI to explain every line, so that you own it. None of them asks the AI to do the task, rank the options, or write your results. T2 is a hand calculation, so it has no prompt. Adapt each prompt to your own approach and variable names, replace each bracketed line with the help output it names, and keep the transcript — it is part of your code deliverable.
T1 — the laydown figure
I am writing MATLAB for a course project. Two toolkit functions I will use are
documented below.
[paste the output of: help FPToolkit.lethalRange]
[paste the output of: help FPToolkit.chain]
My approach: one map for a B-21 on a heading psi that I state. For each site
in S.W, I draw its lethal contour R = FPToolkit.lethalRange(S, id, phi, psi)
for phi = 0:1:360, plotted as E + R.*sind(phi), N + R.*cosd(phi), its MEZ as a
dashed circle, and its LEZ (the LEZ_km column of FPToolkit.chain(S)) as a
dash-dot circle. I also draw the EWR's coverage for the same heading with
FPToolkit.lethalRange(S, "EWR", phi, psi), and mark the IRST sites, the pop-up
prior, and A, T and B. Please write a function plotLaydown(S, psi) that does
exactly this with the toolkit functions, without re-implementing the radar
model. Then explain what each line does, and tell me how to check one point of
one contour by hand.
T3 — the fuel-limited choice
I am writing MATLAB for a course project. The toolkit's route planner is
documented below.
[paste the output of: help FPToolkit.route]
My approach: with r = FPToolkit.edgeRisk(S, Gr, struct()) and w = [0
logspace(0,5,31)], I sweep the ingress with rtIn = FPToolkit.route(S, Gr, r,
S.A, S.T, w) and the egress with rtEg = FPToolkit.route(S, Gr, r, S.T, S.B,
w). My rule for the fuel-limited choice: among all pairs (i, j) with rtIn(i).L
+ rtEg(j).L <= S.sc.Lmax_km, take the pair with the smallest rtIn(i).risk +
rtEg(j).risk; if two pairs tie in risk, take the shorter one. Write a script
that makes the two sweeps with the toolkit, and a MATLAB function [i, j] =
fuelChoice(rtIn, rtEg, Lmax) that implements exactly my rule with plain loops.
Explain each line, and give me a small test case with three routes per leg
that I can check by hand.
T4 — their DRMS along my route
I am writing MATLAB for a course project. The toolkit function below computes
a passive network's CRLB DRMS.
[paste the output of: help FPToolkit.passiveDRMS]
My approach: myRoute.P holds my route's waypoints, and I call [D, nIn, s] =
FPToolkit.passiveDRMS(S, myRoute.P, 1) for 1 km steps. I want one figure: D
against s on a log axis, with infinite values drawn at a 100 km cap, and the
stretches where nIn >= 2 and D >= 10 km shaded. Write the code that makes this
call and this plot, using only what passiveDRMS returns. Explain each line,
including how the shading finds where each stretch starts and ends.
T5 — evaluating every support plan
I am writing MATLAB for a course project. The toolkit functions I will use are
documented below.
[paste the output of: help FPToolkit.edgeRisk]
[paste the output of: help FPToolkit.load]
My plan: loop over the victims ["L1" "M1" "M2" "M3"], over the rows of
S.orbits, and over the SEAD options ["L1" "M1" "M2" "M3" "none"]. For each,
build the plan struct, call FPToolkit.edgeRisk, and pass r to my own T3
function [PS, rtIn, rtEg] = planMission(S, Gr, r), which I have already
written and tested. Store PS in a 4-by-5-by-5 array, and keep rtIn and rtEg
for every plan in cell arrays of the same size so that I can plot any plan's
route later. Then add the SEAD-only cases and the unsupported case. Write the
loops, and a function that prints, for each victim, a table with the orbits as
rows and the SEAD options as columns. Do not rank or pick plans: I will read
the tables and decide. Explain each line.
T6 — the straight leg and the two given doglegs
I am writing MATLAB for a course project. The toolkit functions I will use are
documented below.
[paste the output of: help FPToolkit.popup]
[paste the output of: help FPToolkit.rwrCRLB]
I have pu = FPToolkit.popup(S, myIngress.P). The handout defines two doglegs
from the activation point p0 = pu.p0, relative to my heading psi0 = pu.psi0:
LEFT flies psi0 - 30 deg for 30 km, then psi0 + 30 deg for 30 km; RIGHT flies
psi0 + 30 deg for 30 km, then psi0 - 30 deg for 30 km. Positions are [N E] in
km and headings are degrees clockwise from North, so d km on heading h moves
d*[cosd(h) sind(h)]. Write code that builds the waypoints [p0; w1; w2] for
each dogleg, calls rwrCRLB with S.sc.rwr_spacing_km, and scores each leg with
FPToolkit.score(S, leg, struct('popup', true)); for the straight leg, use
pu.brg and pu.leg. For each of the three legs, print the DRMS, the leg risk,
and the distance from the leg's end to pu.leg(end,:). Explain each line, and
point out anything in my geometry that looks wrong.