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), jamming and burn-through (Block 2), and a 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 what ignoring aspect would cost, choose from a menu of support plans, and recommend the route to fly with the risk it leaves you.
The B-21 here is the L26 flying wing at X band: a quiet nose, beam and tail on a speckle floor near −25 dBsm, with four narrow spikes at ±40° and ±140° off the nose, where a radar looks along the normals to the leading and trailing edges. Its VHF and IR columns are Project 3’s (FP_B21_SignaturePattern.csv).
The project is individual and stands in lieu of a final exam. You write it up as a journal article in IEEE format (at most 2 pages — about 700 words of prose — with three figures and two tables, in a pre-filled template whose method section, Sec. III, comes written but for one sentence), review one classmate’s draft, and revise from the review 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 and draws the three figures, 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.
The tasks#
T1 Threat picture (L32). For a B-21 flying heading 135° (
FPToolkit.plotLaydown(S, 135), Fig. 1): every site’s lethal contour — the wing’s spikes show as spokes beyond a quiet core — the MEZ and LEZ rings, and the EWR’s coverage for the same heading. Name the gaps and the spikes you see: where the spokes point, and why there.T2 Survival metric (L31). The chain to \(p_{\rm shot}\), \(\Delta s\) and \(\lambda\) (cued and autonomous) by hand for L1 and one MR site, checked against
FPToolkit.chain; \(P_S\) for each leg of your T3 route and the binding threat on each leg.T3 Route (L34). Plan each leg over the issued \(w\) sweep, make the fuel-limited choice (
FPToolkit.fuelChoiceapplies the stated rule), and plot both Pareto fronts with that choice (FPToolkit.plotFronts, Fig. 2); then the aspect-blind plan (nose-on \(\sigma\) everywhere): the \(P_S\) it promises, its true \(P_S\), and how its route differs.T4 Support package (L36). Evaluate every plan in
FP_SupportPlans.csv, and only those, each re-planned exactly as in T3 under the same \(L_{\max}\); a table of \(P_S\) and \(\Delta P_S\) — the plan’s re-planned fuel-limited \(P_S\) minus your unsupported fuel-limited \(P_S\); pick one plan and defend it against its nearest rival on a stated ground; draw your pick’s route over the victim’s jammed contour (Fig. 3) at the heading flown on the longest stretch inside the strobe (the longest row ofFPToolkit.strobeCrossings).R Recommendation and Limitations. The route to fly and the residual risk; where the models break, including one L37 trend.
The tasks as written are the whole scope: there are no sensitivities, no extensions and no optional tasks. The project is sized at about 8 hours in all, with the three class periods L38, L39 and L40 included — about five and a half hours outside class. If you are well past that budget, ask for help early.
Materials#
Final Project handout (PDF) — the authoritative tasking, models, deliverables, and rubric
MATLAB bundle · L38_FinalProjectStarter.m↓
Final Project - Peer Review Form.pdf — the form for your peer review at L39
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 the coding tasks 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’s fourteen methods implement every model in the handout — the signature, the kill chain and hazard, lethal and jammed contours, the grid digraph, edge risk under a support plan, Dijkstra with the handout’s tie rule over the issued \(w\) sweep, the stated fuel rule, route scoring, a menu row as a plan, and where a route crosses a jamming strobe — and draw the paper’s three figures (plotLaydown, plotRoute, plotFronts), each sized for one IEEE column and exported to the file the template already includes. They make no decisions: the fuel-limited pair comes from the stated rule, and the support plan you pick and every explanation 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 and prints the sites and the menu, draws the T1 threat picture at the given heading, and plans one ingress route at one weight \(w\).
Timeline#
All submissions go through the course Teams team.
L31 — project issued. Each Block 4 lesson adds a layer: the survival metric (L31), the threat picture (L32), the route (L34), the support package (L36), and the limitations (L37).
L38 — work day.
L39, start of class — complete draft (PDF, through Teams). In class, one peer review: you review one classmate’s draft, and one classmate reviews yours.
L40 — revision work day.
L41, start of class — final paper, response-to-reviewer 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 rubric#
Line |
Points |
|---|---|
Threat picture and survival metric (T1, T2) |
15 |
Route results and the aspect-blind comparison (T3) |
25 |
Support package and recommendation (T4, R) |
20 |
Writing, figures and IEEE form |
15 |
Course citations (≥ 1 lesson per block) |
10 |
Peer review given (specific, accurate, rubric-anchored) |
5 |
Response to reviewer |
5 |
Code reproducibility |
5 |
Total |
100 |
There is no innovation bonus: the Final Project is graded on the rubric alone.
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 or pick the options, or write your results. T1 needs no prompt (FPToolkit.plotLaydown draws it), and T2 is a hand calculation. 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.
T3 — the fronts, the fuel rule and the aspect-blind plan
I am writing MATLAB for a course project. The toolkit functions I will use are
documented below.
[paste the output of: help FPToolkit.route]
[paste the output of: help FPToolkit.fuelChoice]
[paste the output of: help FPToolkit.plotFronts]
My approach: a function [PS, rtIn, rtEg, i, j] = planMission(S, Gr, r) plans
the ingress with rtIn = FPToolkit.route(S, Gr, r, S.A, S.T) and the egress
with rtEg = FPToolkit.route(S, Gr, r, S.T, S.B), leaving w out so that both
use the issued sweep, applies the fuel rule with [i, j] =
FPToolkit.fuelChoice(rtIn, rtEg, S.sc.Lmax_km), and returns PS =
rtIn(i).PS*rtEg(j).PS. My script calls it with r = FPToolkit.edgeRisk(S, Gr,
struct()), draws FPToolkit.plotFronts(rtIn, rtEg, i, j, S.sc.Lmax_km) and
exports it to figures/fronts.pdf. For the aspect-blind plan it calls
planMission again with rB = FPToolkit.edgeRisk(S, Gr, struct('blind', true));
the blind plan's true risk is the sum of r, not rB, over the edges of its two
routes. Write planMission and the script, and print the blind plan's promised
and true P_S. Do not rank or pick anything beyond the stated fuel rule: the
analysis is mine. Explain each line, and show me how to check one route's P_S
from its rt.per by hand.
T4 — evaluating the support menu
I am writing MATLAB for a course project. The toolkit functions I will use are
documented below.
[paste the output of: help FPToolkit.supportPlan]
[paste the output of: help FPToolkit.edgeRisk]
[paste the output of: help FPToolkit.strobeCrossings]
My plan: for each row k of S.support, build p = FPToolkit.supportPlan(S,
S.support.plan(k)) and r = FPToolkit.edgeRisk(S, Gr, p), and pass r to my T3
function [PS, rtIn, rtEg, i, j] = planMission(S, Gr, r), which I have already
written and tested. Keep each plan's route, P = [rtIn(i).P;
rtEg(j).P(2:end,:)], in a cell array so that I can draw any plan later. Write
the loop, and a function that prints one row per plan: the plan name, its SOJ
victim and orbit, its SEAD site, P_S, Delta P_S (P_S minus my unsupported
fuel-limited P_S, a variable PS0 that I pass in), the total length, the fuel
margin, and, for a plan with a jammer, the km flown inside the strobe (the sum
of length_km) and the heading of the longest row of
FPToolkit.strobeCrossings(S, P, p). Do not rank or pick plans: I will read the
table and decide. Explain each line.