Rubric: The Running Project (Heat-Equation Solver)

For grading the progressive project — whether at an interim milestone or as the full Chapter 38 capstone. Weight the categories to match how far the course has progressed (a Chapter-24 milestone should not be graded on parallelism). Suggested capstone weights are in parentheses; a 100-point scale.

Categories

1. Correctness and validation (25%)

  • Excellent: the solver produces physically correct results, validated against the analytical steady state (or another known solution) with a reported error that decreases under grid refinement. A convergence study is included.
  • Proficient: correct results, informally checked against expectation, but no quantitative validation.
  • Developing: runs, but results are unverified or subtly wrong (e.g., boundary conditions mishandled).
  • Beginning: does not run, or produces NaN/nonsense (often a CFL/stability violation left unfixed).

2. Design and modularity (20%)

  • Excellent: clean module hierarchy (kinds, heat_types, heat_io, heat_solver, driver); a purpose-built derived type; clear separation of I/O, numerics, and driver; stable interfaces.
  • Proficient: modular, but with some tangling of concerns or a monolithic module.
  • Developing: mostly one big program; little structure.
  • Beginning: unstructured; global state; hard to follow.

3. Modern Fortran style (15%)

  • Excellent: implicit none everywhere; intent on every argument; real(dp) with kind-suffixed literals; allocatable (not raw pointers); assumed-shape arrays; lowercase, well-named. No legacy constructs.
  • Proficient: mostly modern, with a few lapses.
  • Developing: works but drifts toward legacy habits (missing intent, default precision, goto).
  • Beginning: FORTRAN-77-style code in a modern assignment.

4. Performance (15% — from Part VII on)

  • Excellent: profiled (a profile is included), hot loop identified, optimized with justification (loop order for column-major, appropriate flags), and a measured before/after speedup reported.
  • Proficient: some optimization with correct reasoning, but limited measurement.
  • Developing: ad hoc changes without profiling or measurement.
  • Beginning: no attention to performance where the course expected it.

5. Parallelism (15% — capstone only)

  • Excellent: correctly parallelized (OpenMP, coarrays, or MPI) with no race conditions; a scaling study (speedup vs. cores) is reported and discussed in light of Amdahl's Law.
  • Proficient: correct parallel results, limited scaling analysis.
  • Developing: parallel code with correctness issues (races) or no speedup.
  • Beginning: serial where parallel was required.

6. Documentation, reproducibility, and presentation (10%)

  • Excellent: a README, build instructions, recorded compiler/flags/inputs, at least one visualization (VTK/ParaView), and — for the capstone — a short paper-style write-up (problem, method, validation, results, performance).
  • Proficient: builds and is documented, but reproducibility details or the figure are thin.
  • Developing: minimal documentation; hard to build.
  • Beginning: no instructions; not reproducible.

Capstone (Chapter 38) weighting

Correctness/validation 25 · Design 20 · Style 10 · Performance 15 · Parallelism 15 · Presentation 15.

Academic-integrity note

Because the complete reference solver is in Appendix I, grade on understanding, not just a working artifact: require a short oral or written explanation of two design decisions and one performance result. A student who built it understands it; a student who copied it usually cannot explain the CFL condition or why their loop order matters.