Appearance

Capstone Project ​

Record a complete, end-to-end workflow that stitches everything together: documenting your study (daily log + meeting notes), creating a study README, running a small parametric solver batch, and visualizing the results in ParaView. Submit one short recording plus a few screenshots as proof.

Time: 40–60 minutes Deliverables: 1 short recording (3–5 min) + 6–8 screenshots (listed below)

Step 1 — Start with documentation (Daily log + Meeting note) ​

  • In Obsidian, create today’s Daily note (via the Daily Notes button) and fill it with your plan for this capstone: goals, tasks, and expected outputs.
  • Create a Meeting note (Templater) with: attendees (you/mentor), agenda (capstone workflow), decisions (scope, file names), and actions.
  • Add links between these two notes and your Library index so reviewers can follow context.

Screenshot A: Daily note showing goals, tasks, end-of-day section, and internal links. Screenshot B: Meeting note with Agenda, Decisions, Actions, and References.

Step 2 — Create your study README (workshop) ​

Inside your project’s workshop area (e.g., 2_study/2_workshop/<capstone-study>/), add a README.md structured as:

markdown
# Capstone Study — Cantilever Parametric Run

## Study
Objective, model summary (beam dims, BCs), parameter sweep (Young’s modulus values),
and expected trends.

## Results
List of generated cases, key numeric indicators (e.g., max displacement),
and links to outputs.

## Conclusions
What changed across cases? Any convergence or sensitivity notes?
Next experiments.

Screenshot C: README.md open in Obsidian showing Study / Results / Conclusions sections.

Step 3 — Generate the solver cases programmatically ​

Use your automation pattern to create five variants of Young’s modulus (E). If you’ve completed the automation exercise, you can reuse the same layout: a template FEniCS script, a Python generator to write five case scripts, and an outputs/ directory per case.

Typical files:

automation_study/
  base_solver_template.py
  generate_cases.py
  cases/case_*.py        # generated
  outputs/case_*/        # results will appear here

Run:

bash
python3 generate_cases.py

Screenshot D: Folder tree showing cases/ and outputs/ populated with five case names.

Step 4 — Batch-run the cases with a bash script ​

Create run_all.sh that loops over cases/case_*.py, executes each, and stores logs/artifacts (XDMF, VTK, or XDMF+HDF5) under its case folder. Run it and verify all cases complete.

bash
chmod +x run_all.sh
./run_all.sh

Screenshot E: Terminal showing the batch run progressing through all five cases and finishing cleanly. Screenshot F: outputs/ directory view confirming results exist for all five cases (e.g., u.xdmf, u_mag.xdmf).

Step 5 — Visualize one case in ParaView ​

Open ParaView and load one case result (e.g., outputs/case_3/.../u_mag.xdmf or results.vtu). Click Apply, switch Representation to Surface/Surface with Edges, Color By a scalar (e.g., u_mag), Rescale to Data Range, and add at least one filter (Slice, Threshold, or Warp by Scalar) to expose structure.

Screenshot G: Scalar field view with scalar bar visible. Screenshot H: A filtered view (e.g., Slice or Threshold) clearly showing internal variation.

Step 6 — Capture the capstone recording (3–5 minutes) ​

Record a concise screen-capture that shows the entire flow:

  1. Open Obsidian → show Daily note and Meeting note.
  2. Open the workshop README.md with Study/Results/Conclusions.
  3. Run the bash script (or show its completed terminal output) and the populated outputs/ folder.
  4. Switch to ParaView, load one result, Apply, Color By scalar, and apply a filter.

Keep it tight and readable; show the key screens and outputs in one pass.

Recording: 3–5 minutes, no narration required (optional).

Acceptance checklist (pass/fail) ​

  • Daily and Meeting notes created and meaningfully filled (with links).
  • Workshop README.md present with Study / Results / Conclusions.
  • Five case scripts generated automatically; outputs exist for each.
  • Batch execution completed without errors; logs or terminal proof included.
  • ParaView visualization shown with scalar field and at least one filter applied.

This capstone demonstrates a cohesive, professional workflow: document → generate → run → visualize. You’ll show that you can plan studies, keep reproducible records, automate parameter sweeps, and communicate results with clear visuals—exactly the habits needed for reliable engineering simulations.

Completion Note ​

Finally, this marks the completion of the entire training module. By reaching this stage, you now have hands-on experience with the complete engineering simulation pipeline — using Salome for geometry and meshing, FEniCS for solver development, ParaView for visualization, WSL Ubuntu for Linux-based workflows, Docker for containerized environments, VS Code for editing and debugging, and Obsidian for documentation.

More importantly, you now understand how to orchestrate all these tools together — integrating design, computation, and analysis into a single, efficient, and reproducible workflow.