Special relativity, quantum and nuclear physics, Monte Carlo, orbit and PDE solvers, fitting with uncertainties, data acquisition and research computing, all in Python.

Computational & Modern Physics

## Why it matters

A measurement without an uncertainty is not a result. Physicists fit models to data every day: a decay constant from counts, a spring constant from extensions, `g` from a pendulum. The fit gives the best parameters, but the questions that matter are **how sure are we** and **does the model actually fit**. Weighted least squares and chi-squared answer both.

## Uncertainties first

Each data point `y_i` has an uncertainty `sigma_i`, its standard deviation. Points with small `sigma` should count more. Two rules for propagating uncertainties you will use constantly (for independent errors):

```text
sum or difference:  sigma_f^2 = sigma_a^2 + sigma_b^2
product or ratio:   (sigma_f / f)^2 = (sigma_a / a)^2 + (sigma_b / b)^2
```

## Weighted least squares for a line

To fit `y = m x + b`, choose `m` and `b` that minimise

```text
chi^2 = sum of ((y_i - (m x_i + b)) / sigma_i)^2
```

With weights `w_i = 1 / sigma_i^2`, the answer has a closed form:

```text
S = sum w     Sx = sum w x     Sy = sum w y
Sxx = sum w x^2     Sxy = sum w x y     D = S*Sxx - Sx^2

m = (S*Sxy - Sx*Sy) / D          sigma_m = sqrt(S / D)
b = (Sxx*Sy - Sx*Sxy) / D        sigma_b = sqrt(Sxx / D)
```

## Judging the fit: chi-squared

Each term in `chi^2` asks: how many sigmas away is this point from the line? If the model is right and the `sigma` values are honest, each term is about 1 on average. With `N` points and 2 fitted parameters there are `N - 2` **degrees of freedom**, and

```text
reduced chi^2 = chi^2 / (N - 2)   ~ 1 for a good fit
```

- **Much larger than 1:** the model is wrong, or the uncertainties are underestimated.
- **Much smaller than 1:** the uncertainties are probably overestimated.
- Always look at the **residuals** too: a pattern (a curve, a trend) means the model misses something even if `chi^2` looks fine.

## Worked example: a cart on a track

Position of a cart every second, each with `sigma = 0.03 m`:

```text
t (s): 0     1     2     3     4     5
x (m): 0.02  0.51  1.03  1.48  2.05  2.49
```

The weighted fit gives

```text
m = 0.498 +/- 0.007 m/s     (the speed)
b = 0.019 +/- 0.022 m       (consistent with starting at 0)
chi^2 = 3.60 for 4 degrees of freedom -> reduced chi^2 = 0.90
```

The reduced chi-squared near 1 says a constant speed describes the data at this precision. Report it as `v = 0.498 +/- 0.007 m/s`: round the uncertainty to one or two significant figures and the value to match.

## With NumPy and SciPy

```python
import numpy as np

t = np.array([0, 1, 2, 3, 4, 5.0])
x = np.array([0.02, 0.51, 1.03, 1.48, 2.05, 2.49])
sigma = np.full(6, 0.03)

coef, cov = np.polyfit(t, x, 1, w=1 / sigma, cov="unscaled")
print(coef, np.sqrt(np.diag(cov)))   # [0.498 0.019] [0.0072 0.0217]
```

Note that `np.polyfit` takes weights `1/sigma`, not `1/sigma^2`, and `cov="unscaled"` returns errors based on your sigmas. For nonlinear models, `scipy.optimize.curve_fit(f, x, y, sigma=sigma, absolute_sigma=True)` does the same job; `absolute_sigma=True` tells it your sigmas are real uncertainties rather than relative weights.

## Common mistakes

- **Unweighted fits for data with different uncertainties,** which lets noisy points pull the line.
- **Passing `1/sigma^2` to `polyfit`** (it squares the weights itself).
- **Quoting too many digits,** such as `0.4977143 +/- 0.0071714`.
- **Ignoring a reduced chi-squared of 5** because the line "looks fine".
- **Forgetting the degrees of freedom:** divide by `N - p`, where `p` is the number of fitted parameters.

## Recap

- Weighted least squares minimises chi-squared with weights `1/sigma^2`.
- Parameter errors come from the same sums: `sigma_m = sqrt(S/D)`, `sigma_b = sqrt(Sxx/D)`.
- Reduced chi-squared near 1 plus patternless residuals means a believable fit.

## Try it

Open the **Do** tab to write a weighted line fit with parameter uncertainties and chi-squared, checked against NumPy.


Fit a straight line to data with uncertainties, quote the parameter errors, and judge the fit with chi-squared.

Data analysis and fitting

Least Squares Fit and Graphing in Python

Chi Squared

Install phyphox (or open a new Arduino Uno project in Wokwi and add a potentiometer wired to 5V, GND and A0, with the logger sketch).

Lay the phone flat and still on a table. In phyphox open 'Acceleration with g' and record for 30 seconds without touching it (in Wokwi, run the sketch for 30 seconds without moving the potentiometer).

Export the data as CSV (phyphox: menu, Export Data, CSV) or copy the serial output into a text file. Write down the date, device model and settings in a notes file next to it.

Load the file in Python with pandas or numpy. Find the sample rate from the timestamps (number of samples divided by elapsed time) and check whether the spacing is steady.

Compute the mean and standard deviation of the z-axis (or voltage) column. The phone's mean should be close to 9.81 m/s^2; note how far off it is.

Compute the standard error of the mean (std / sqrt(N)) and compare it with the difference from 9.81. Decide whether the difference is noise or a calibration offset.

Repeat with the phone resting on its long edge (or turn the potentiometer to a new fixed position) and check that the reading moves to a different axis (or voltage) as expected.

Write three sentences: the sample rate, the noise level per sample, and one systematic effect you would calibrate out in a real experiment.

## Why it matters

Every physics result starts as a voltage in an instrument. **Data acquisition (DAQ)** is the chain that turns a physical quantity (temperature, acceleration, light, charge) into numbers in a file. Physicists design, calibrate and debug these chains constantly, and many analysis problems are really acquisition problems: the wrong sample rate, a missing timestamp, an uncalibrated sensor.

## The DAQ chain

1. **Sensor or transducer:** converts the quantity into an electrical signal. Examples: a thermistor (resistance changes with temperature), a photodiode (current from light), a MEMS accelerometer (capacitance changes with acceleration), a photomultiplier (charge pulses from single photons).
2. **Signal conditioning:** amplifiers, filters and dividers that bring the signal into the converter's range and remove noise. An **anti-aliasing low-pass filter** removes frequencies the converter can't sample correctly.
3. **Analog-to-digital converter (ADC):** samples the voltage at fixed times and rounds it to an integer.
4. **Timing and storage:** a clock stamps every sample; software writes the data with its metadata.

## Resolution

An `n`-bit ADC splits its input range into `2^n` steps.

```text
step size = V_range / 2^n
10-bit, 0-5 V:   5 / 1024  = 4.9 mV per count
12-bit, 0-3.3 V: 3.3 / 4096 = 0.81 mV per count
16-bit, +/-10 V: 20 / 65536 = 0.31 mV per count
```

A reading of 512 counts on a 10-bit, 5 V ADC is `512 * 5 / 1024 = 2.50 V`. Resolution is not accuracy: an ADC with tiny steps can still be offset or noisy, which is why you **calibrate** against a known reference.

## Sampling rate and aliasing

The **Nyquist criterion** says you must sample faster than twice the highest frequency in the signal. A 60 Hz signal sampled at 100 samples per second does not just look rough, it masquerades as a 40 Hz signal (`100 - 60`). Once aliased, no software can undo it, so you filter before the ADC and choose a sample rate well above twice the frequencies you care about (five to ten times is common).

## Noise and averaging

Random noise shrinks when you average: the standard error of `N` independent readings is `sigma / sqrt(N)`. Averaging does nothing for systematic errors, such as a sensor that reads 0.2 °C high; only calibration fixes those.

## Phones and microcontrollers as DAQ

- **Smartphone sensors** are real MEMS instruments. The free **phyphox** app, from RWTH Aachen University (https://phyphox.org), records the accelerometer, gyroscope, magnetometer, light sensor and microphone and exports CSV files.
- **Microcontrollers** such as Arduino boards read sensors through built-in ADCs (`analogRead` returns 0 to 1023 on a 10-bit, 5 V Uno) and send data over USB serial. The free **Wokwi** browser simulator (https://wokwi.com) runs Arduino code with virtual sensors and potentiometers, so you can practise without hardware.

A minimal Arduino logger looks like this:

```cpp
void setup() { Serial.begin(115200); }
void loop() {
  int counts = analogRead(A0);             // 0..1023
  float volts = counts * 5.0 / 1023.0;
  Serial.print(millis()); Serial.print(",");
  Serial.println(volts, 3);
  delay(10);                               // about 100 samples per second
}
```

## Good data habits

- Record **timestamps** with every sample, not just a sample count.
- Save **metadata**: sensor model, settings, sample rate, units, date, who and where.
- Keep **raw data** untouched; write processed data to new files.
- Use plain, documented formats (CSV for small data, HDF5 for large arrays).

## Real labs

Lab DAQ hardware, high-voltage detector supplies, lasers and cryogenics need institutional training and supervision. At home, stick to phones, simulators and battery-powered kits.

## Common mistakes

- **Sampling too slowly** and analysing an aliased signal.
- **Trusting raw counts** without converting units and calibrating.
- **Losing timing** by assuming a perfectly steady sample rate; phones in particular vary.
- **Averaging away a real signal** with too long a window.

## Recap

- Sensor, conditioning, ADC, timing and storage make up the chain.
- Step size = range / 2^n; resolution is not accuracy.
- Sample faster than twice the highest frequency, and filter first.
- Save timestamps, metadata and raw data.

## Try it

Open the **Do** tab to record accelerometer data with phyphox (or a simulated sensor in Wokwi) and analyse its noise and sample rate.


Explain sensors, analog-to-digital conversion and sampling, and record and analyse real data from a phone or a simulated microcontroller.

Instrumentation and DAQ

Test and Measurement Basics - DAQ | Episode 2 - Define Data Acquisition (DAQ)

Phyphox - Physical Phone Experiments

## Why it matters

Modern physics runs on software. Lattice QCD, climate models, galaxy simulations, gravitational-wave searches and detector reconstruction all need more computing than a laptop, and their results are only as trustworthy as the code. Knowing how **high-performance computing (HPC)** works and how to write **reproducible research software** is now a core physicist skill, and research software engineering is a career in its own right.

## What a cluster is

An HPC cluster is many computers (**nodes**) connected by a fast network.

- **Login nodes:** where you connect with `ssh`, edit files and submit jobs. Never run heavy work here.
- **Compute nodes:** each has many CPU cores (often 32 to 128), lots of memory, and sometimes GPUs.
- **Interconnect:** a low-latency network (such as InfiniBand) so nodes can exchange data quickly.
- **Shared parallel file system:** large, fast storage visible from every node, usually with a scratch area that is purged regularly and is not backed up.

## Schedulers and jobs

You don't run programs directly on compute nodes; you ask a **scheduler** (Slurm is the most common) for resources, and it queues your job until they are free.

```bash
#!/bin/bash
#SBATCH --job-name=heat-scan
#SBATCH --nodes=1
#SBATCH --ntasks=32
#SBATCH --time=02:00:00
#SBATCH --mem=64G

module load python/3.12
srun python run_scan.py --config scan.yaml
```

You submit with `sbatch job.sh`, check the queue with `squeue`, and cancel with `scancel`. Asking for realistic time and memory gets your job started sooner. Computing time is a shared, allocated resource, often granted through proposals.

## Kinds of parallelism

- **Embarrassingly parallel:** many independent runs (parameter scans, Monte Carlo seeds). The easiest and most common; use job arrays.
- **Shared memory (OpenMP, threads):** many cores on one node working on the same arrays.
- **Distributed memory (MPI):** processes on many nodes, each owning part of the problem (for example, part of a grid) and exchanging boundary data with messages.
- **GPUs (CUDA, HIP, or Python tools such as CuPy and JAX):** thousands of simple cores, ideal for dense array maths.

## Amdahl's law

If a fraction `p` of the work can run in parallel on `N` cores, the speed-up is limited:

```text
S = 1 / ((1 - p) + p / N)
p = 0.9, N = 8:    S = 1 / (0.1 + 0.1125) = 4.7
p = 0.9, N = 1000: S = 1 / (0.1 + 0.0009) = 9.9   (never more than 10)
```

The serial part dominates quickly. **Strong scaling** asks how fast a fixed problem gets with more cores; **weak scaling** asks whether a problem that grows with the core count keeps the same run time. Measure both before asking for a large allocation.

## Reproducible research software

A result is reproducible if someone else (or you, in a year) can regenerate it from the same data and code.

- **Version control:** every analysis lives in git; record the commit hash with every result.
- **Pinned environments:** a `requirements.txt` with versions, a conda `environment.yml`, or a container (Apptainer, Docker).
- **Seeds and configuration:** random seeds and parameters live in config files, not in your head.
- **Tests:** check the code against known answers (exact solutions, conservation laws), like the checks in this course.
- **Data provenance:** keep raw data read-only and record each processing step.
- **Sharing and credit:** publish code with a licence, archive a release with a DOI (Zenodo is free), add a `CITATION.cff` file, and follow the FAIR principles (findable, accessible, interoperable, reusable).

## Careers and requirements

National labs, universities and companies employ physicists and research software engineers (RSEs) for this work. Physicist roles need at least a bachelor's degree in physics, and most research positions require a PhD. Many universities offer free HPC training; the Carpentries (https://carpentries.org) teach the core software habits. Checked on 2026-10-23.

## Recap

- Clusters have login and compute nodes, a fast network and shared storage; a scheduler such as Slurm runs your jobs.
- Parallelism ranges from independent runs to MPI and GPUs; Amdahl's law caps the speed-up.
- Version control, pinned environments, seeds, tests and DOIs make research code reproducible.


Explain how clusters, schedulers and parallel code work, and the habits that make research software reproducible.

HPC and research software

High Performance Computing (HPC) - Computerphile

Research Software Engineers and their role for open and reproducible research

Fitting with uncertainties and chi-squared, recording sensor data, and the clusters and habits behind reproducible research code.