Python for Scientific Computing Training Course

Participants can use NumPy arrays to perform efficient multidimensional numerical calculations.

• NumPy ndarray creation, dtypes, shapes, strides, and memory layout
• Array indexing with slices, masks, integer positions, and views
• Broadcasting rules applied to parameter grids and measurement matrices
• Universal functions, reductions, and axis conventions for multidimensional calculations
• Vectorised transformations replacing Python loops in numerical kernels
• Missing-value handling using NaN, masked arrays, and validity flags

Participants can import, validate, reshape and store structured scientific datasets reproducibly.

• Delimited, Excel, JSON, and fixed-width files imported reproducibly
• pandas DataFrames indexed, reshaped, merged, and aggregated for experiments
• Datetime parsing, time zones, resampling, and irregular observation intervals
• Data dictionaries define units, provenance, allowable ranges, and identifiers
• Validation rules detect duplicates, impossible values, and schema changes
• Parquet storage choices balance file size, speed, and interoperability

Participants can create clear figures that accurately communicate scientific evidence and uncertainty.

• Matplotlib figures use object-oriented axes, labels, scales, and annotations
• Colour maps selected for perceptual order, accessibility, and variable meaning
• Error bars, confidence bands, and uncertainty intervals displayed correctly
• Small multiples compare scenarios, groups, time periods, and distributions
• Publication-ready exports control resolution, fonts, dimensions, and file formats
• Diagnostic plots reveal outliers, missingness, skewness, and measurement artefacts

Participants can select, estimate and communicate statistical measures appropriate to measured data.

• Descriptive statistics distinguish location, spread, shape, and sampling variability
• Probability distributions selected from data-generating assumptions and diagnostics
• Bootstrap confidence intervals estimated for nonlinear statistics and small samples
• Permutation tests compare groups without normality assumptions
• Linear regression assessed through residual plots, influence, and collinearity
• Effect sizes and confidence intervals reported alongside p-values

Participants can use simulation to estimate uncertainty, sensitivity and probabilistic model outputs.

• Pseudo-random sampling uses generators, seeds, and reproducible streams
• Monte Carlo estimates quantify uncertainty in model outputs
• Latin hypercube sampling covers multidimensional input ranges efficiently
• Probability distributions parameterised from empirical measurements and expert assumptions
• Sensitivity analysis ranks influential inputs using sampled simulations
• Convergence diagnostics compare estimate stability against simulation count

Participants can formulate and solve matrix-based scientific problems using appropriate numerical methods.

• Vectors, matrices, tensors, and dimensions represented with NumPy arrays
• Matrix multiplication, transposition, and norms support scientific formulations
• LU, QR, and singular-value decompositions solve numerical problems
• Condition numbers identify unstable systems and sensitive solutions
• Least-squares fitting handles overdetermined measurements and residual error
• Sparse matrix formats reduce memory use for structured systems

Participants can assess numerical error and choose methods that produce stable computational results.

• IEEE 754 representation explains rounding, underflow, overflow, and cancellation
• Absolute and relative error measures guide tolerance selection
• Stable formulas avoid subtractive cancellation and scaling failures
• Finite-difference checks verify analytical derivatives against numerical approximations
• Convergence rates distinguish first-order and higher-order numerical schemes
• Unit tests capture boundary conditions, tolerances, and expected precision

Participants can estimate values, calculate integrals and solve nonlinear equations from scientific data.

• Linear, cubic spline, and radial basis interpolation compared
• Extrapolation risks assessed against physical bounds and measurement support
• Numerical quadrature uses trapezoidal, Simpson's, and adaptive methods
• Root-finding applies bisection, Newton, and secant algorithms
• Bracketing intervals and stopping criteria prevent false convergence
• Interpolants validated using withheld observations and residual patterns

Participants can formulate optimisation problems and assess the reliability of fitted parameter values.

• Objective functions express costs, fit errors, and design trade-offs
• Bounded optimisation applies gradients, constraints, and feasible regions
• Derivative-free methods handle discontinuous, noisy, or expensive objectives
• Parameter scaling improves optimiser conditioning and convergence behaviour
• Multiple starting points expose local minima and identifiability issues
• Optimisation results reported with constraints, tolerances, and diagnostics

Participants can implement, solve and validate ordinary differential equation models in Python.

• Initial-value problems formulated from rates, states, parameters, and inputs
• Explicit Euler and Runge-Kutta methods compared for accuracy
• Adaptive step sizes control local error during integration
• Stiff systems recognised through stability limits and solver behaviour
• Event functions capture thresholds, switches, and termination conditions
• Model trajectories checked against conservation laws and observations

Participants can discretise and assess simple spatial models using finite-difference methods.

• Finite-difference grids represent spatial domains, boundaries, and initial conditions
• Diffusion and wave equations discretised using explicit schemes
• Courant-Friedrichs-Lewy conditions determine stable time-step selections for explicit finite-difference schemes
• Boundary conditions implemented as Dirichlet, Neumann, and periodic cases
• Grid refinement studies estimate discretisation error and convergence
• Scientific fields visualised through contours, heatmaps, and cross-sections

Participants can analyse sampled signals, identify periodic behaviour and filter unwanted noise.

• Sampled signals characterised by frequency, amplitude, phase, and noise
• Fast Fourier transforms reveal periodic components and spectral leakage
• Window functions reduce edge effects before spectral estimation
• Digital filters remove noise while preserving relevant signal bands
• Convolution and correlation quantify response patterns and time lags
• Sampling rates checked against Nyquist limits and aliasing risks

Participants can manage gridded and multidimensional datasets while preserving coordinates and metadata.

• NetCDF and HDF5 datasets inspected for dimensions, coordinates, and metadata
• Labelled arrays align variables by coordinates rather than positions
• Chunked computations process large gridded datasets within memory limits
• Coordinate reference systems documented before spatial calculations and mapping
• Missing grid cells distinguished from valid physical zero values
• Metadata records units, conventions, calibration, and processing history

Participants can identify computational bottlenecks and improve runtime and memory use responsibly.

• Profiling separates algorithmic bottlenecks from input-output and plotting costs
• Array expressions reduce interpreter overhead in repeated calculations
• Memory profiling identifies copies, temporary arrays, and oversized dtypes
• Chunking strategies process datasets exceeding available memory capacity
• Parallel task decomposition distinguishes independent simulations from shared-state computations
• Benchmark protocols compare runtime, memory, accuracy, and reproducibility

Participants can structure, test and review scientific code for dependable technical use.

• Scientific modules organised around data access, models, and visualisation
• Pytest unit tests cover deterministic functions and edge cases
• Property-based tests probe invariants, ranges, and numerical relationships
• Version control commits isolate changes to code, data, and documentation
• Code reviews assess assumptions, readability, tests, and computational cost
• Continuous integration runs tests on clean, repeatable environments

Participants can package an analysis so another analyst can rerun and assess it.

• Environment specifications pin package versions and interpreter requirements
• Configuration files separate model parameters from source code
• Data provenance records sources, transformations, timestamps, and responsible analysts
• Random seeds, run identifiers, and outputs support result replication
• README files state installation steps, inputs, methods, and limitations
• Research artefacts packaged for handover, audit, and later reuse

Participants can calibrate models, evaluate predictive performance and report uncertainty clearly.

• Calibration estimates model parameters from observed measurements and constraints
• Train-test splits distinguish fitting performance from predictive performance
• Cross-validation assesses parameter choices when observations are limited
• Residual diagnostics identify bias, heteroscedasticity, and autocorrelation
• Uncertainty propagation carries input ranges through computed predictions
• Validation reports state acceptance criteria, failures, and model limits

Participants can communicate computational findings with sufficient evidence for technical decisions.

• Technical reports state question, data lineage, method, results, and limits
• Figures selected to support decisions rather than decorate findings
• Tables report units, significant figures, uncertainty, and sample sizes
• Assumptions logged with rationale, evidence, and potential consequences
• Peer review checklists test traceability, reproducibility, and interpretation
• Stakeholder briefings distinguish observed results from modelled scenarios

Participants can scope a computational project around decisions, data requirements and acceptance criteria.

• Problem statements translate operational decisions into measurable computational questions
• Acceptance criteria define accuracy, turnaround time, and output requirements
• Analysis plans sequence data checks, modelling, validation, and reporting
• Risk registers address data quality, assumptions, dependencies, and misuse
• Computational workflows scoped for laboratory, engineering, finance, and public-health cases
• Peer feedback prioritises technical defects, clarity, and decision relevance

Participants can build, review and present a complete reproducible scientific analysis addressing a defined technical question.

• Capstone problem framed with decision context, data scope, and success criteria
• Reproducible Python workflow ingests, validates, analyses, and visualises source data
• Scientific model selected, parameterised, tested, and checked against assumptions
• Numerical accuracy, uncertainty, and sensitivity documented with supporting evidence
• Peer review identifies defects, unsupported claims, and reproducibility gaps
• Final presentation communicates findings, limitations, and recommended actions