Projectile Data Lab (PDL) Framework

• Projectile Data Lab (PDL) is a data-centric framework that organizes projectile experiments, simulations, and model comparisons across educational and research settings.
• It integrates Tracker video analysis, Python-based computational modeling, and PhET/CODAP simulations to extract and validate projectile motion parameters.
• PDL facilitates misconception testing, uncertainty analysis, and reproducible workflows, enabling precise parameter extraction and robust experimental comparisons.

Projectile Data Lab (PDL) is a designation used across several projectile-centered instructional and research settings. In introductory mechanics, it denotes laboratory workflows built around Tracker video analysis and video-modeling for projectile motion (Wee et al., 2012), a Python/Jupyter framework for analytical simulation, parameter-space maps, and iso-curves (Sánchez et al., 9 Jan 2026), and a purpose-built PhET simulation integrated with the Common Online Data Analysis Platform (CODAP) to teach measurement uncertainty in a projectile context (Liu et al., 30 Sep 2025). In a separate but related usage, PDL also appears as an entry or ingestion framework for projectile-related datasets and models, including heavy-ion fragment momentum distributions (Koulouris et al., 2021), projectile fragmentation cross-section libraries (Mallik et al., 2011), dense-suspension impact rheology (Egawa et al., 2019), and hypervelocity launcher performance data (Huneault et al., 2022). This suggests that PDL functions not as a single canonical software package, but as a recurring data-centric framework for organizing projectile experiments, simulations, and model comparisons.

1. Scope and principal usages

The available literature uses the term “Projectile Data Lab” in multiple technically distinct ways. In the pedagogical literature, PDL refers to lab environments in which students collect, fit, and interpret projectile-motion data. In the data-archival and modeling literature, it refers to structured entries or implementation guides for projectile-related observables, equations, and comparison workflows.

Usage	Core platform	Stated emphasis
Tracker-based PDL	Tracker / Open Source Physics	Video-analysis, video-modeling, misconception testing
Python-based PDL	Jupyter notebook with Python visualizations	Analytical trajectories, parameter-space maps, iso-curves, reproducibility
PhET/CODAP PDL	PhET simulation with CODAP integration	Measurement uncertainty, noise, repeated trials, statistical analysis
PDL entry / library usage	Structured data summaries and model formulae	Cross sections, momentum distributions, launcher data, impact rheology

A plausible implication is that PDL is best understood as an organizational label for projectile phenomena that are treated through explicit data acquisition, export, model fitting, and iterative comparison rather than through a single disciplinary definition.

2. Tracker-based projectile-motion laboratory

The Tracker-based PDL is described as a workflow combining video-analysis and video-modeling for projectile motion (Wee et al., 2012). The video-analysis side consists of importing any video of a projectile, calibrating spatial scale with a known reference, digitizing the projectile’s centroid frame by frame, and recording time stamps together with $x$ and $y$ positions. The video-modeling side consists of building a dynamic-particle model from the measured initial conditions, defining forces and mass, overlaying the simulated trajectory onto the real video, and adjusting parameters such as $v_0$, launch angle $\theta$, $g$, and drag coefficient $k$ to refine the fit.

The kinematic model is the standard ideal projectile decomposition: $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$ with

$v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$

Tracker’s fitting operations are used directly on the measured data. In the $X$-vs-$t$ plot, a line fit returns

$y$0

with $y$1 and $y$2. In the $y$3-vs-$y$4 plot, a parabola fit returns

$y$5

with $y$6, $y$7, and $y$8. The cited example gives $y$9, $v_0$0, $v_0$1, $v_0$2, and $v_0$3, implying $v_0$4. From the fitted components, the launch speed and launch angle are computed as

$v_0$5

The guide is explicit about experimental setup. The camera or tripod is mounted so that the flight plane is roughly perpendicular to the lens; a calibration stick is placed in the same plane as the trajectory; minimal parallax is ensured by keeping the camera axis level with the flight plane. The capture recommendations are frame rate $v_0$6 fps, preferably $v_0$7 fps, resolution $v_0$8 p, full-flight field of view, and good lighting with high contrast. Tracking can be manual through a “Point Mass” and “Manual Tracking,” or automatic with “Auto Tracker” when the object has a distinctive color marker. Raw data are exported through Data ▶ Export ▶ ASCII as a .csv file, after inspection for outliers and mis-clicks.

A central pedagogical function of this PDL is misconception testing. The guide identifies three recurrent misconceptions: a “need for a horizontal force” (“Impetus Theory”), the idea that an upward force sustains vertical motion, and the expectation of significant air resistance in low-speed tosses. In the prescribed workflow, students deliberately set $v_0$9, $\theta$0, or $\theta$1 and observe that the overlaid model diverges from the measured motion. Iterating to $\theta$2, $\theta$3, and $\theta$4 yields the correct overlay. The guide therefore frames juxtaposition of model and video as immediate visual evidence for Newton’s First Law and for the dominance of gravity in classroom projectile experiments. Assessment practices include submission of fitted parameters and uncertainties, computed $\theta$5 and $\theta$6, and reflections on how altering $\theta$7 or $\theta$8 changed the fit.

3. Computational PDL in Python and Jupyter

A second formulation of PDL is a computational and pedagogical framework based on Python visualizations and reproducible simulations (Sánchez et al., 9 Jan 2026). Its analytical background assumes the absence of air resistance under uniform gravity $\theta$9. With launch speed $g$0 and angle $g$1,

$g$2

and

$g$3

Eliminating $g$4 yields

$g$5

which is a parabola $g$6 with

$g$7

From this formulation,

$g$8

The implementation guide centers on a Jupyter notebook named ProjectileDataLab.ipynb. The notebook imports numpy and matplotlib, sets $g$9, and defines helper functions trajectory_xy, max_height, and horizontal_range. It then plots multiple trajectories as functions of launch angle for fixed $k$0, and as functions of initial speed for fixed $k$1. The framework extends from individual trajectories to $k$2 parameter-space maps constructed with np.meshgrid, yielding arrays

$k$3

These are rendered as filled contours of range and height.

A distinctive feature is the treatment of iso-outcome curves. For a fixed target range $k$4 or target height $k$5, the guide solves for the launch speed as a function of angle: $k$6 The interpretation given in the guide is that the iso-range curve has two branches, $k$7 and $k$8, because $k$9 is symmetric; by contrast, the iso-height curve has only one branch because $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$0 is monotonic on $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$1. The reference point $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$2 is reproduced at the intersection of the iso-range and iso-height curves.

Reproducibility is made explicit. Parameter sweeps are performed via np.linspace. No random numbers are used in the core PDL; if randomness is introduced, for example through wind gusts, the guide specifies np.random.seed(12345). Results are flattened into a pandas DataFrame with columns "theta_deg", "v0", "H", and "R" and exported to PDL_parameter_space.csv. Version control is recommended through Git or GitHub with a requirements.txt including matplotlib==3.x, numpy==1.x, and pandas==1.x. Pedagogical activities include parameter sensitivity near $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$3, inversion for $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$4 from measured $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$5, and an extension in which a drag term $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$6 is added in an ODE solver via scipy.integrate.odeint.

4. Noise-enhanced PhET/CODAP PDL and measurement uncertainty

A third major usage of PDL is a purpose-built PhET simulation integrated with CODAP, designed specifically to teach measurement uncertainty in introductory physics (Liu et al., 30 Sep 2025). Its explicit pedagogical aim is to give students a deep, practice-based understanding of measurement uncertainty. The learning goals include representing and quantifying variability through repeated measurements, histograms, data tables, and summary statistics; distinguishing single-trial versus multi-trial uncertainty; interpreting “$$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$7” notation and error bars in terms of probability and confidence intervals; identifying sources of random uncertainty; and using measurement tools such as a tape measure, stopwatch, and interval selection. Advanced goals include exploring how sample size affects precision, propagating uncertainties through functions, and fitting histograms with Gaussian curves. These goals are tied to the SPRUCE assessment objectives and to additional instructor-articulated needs.

The technical core of the simulation is an explicit noise model. Launch speed and launch angle are drawn from independent Gaussian distributions around user-selected nominal values: $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$8 Six “mystery” launchers have pre-configured $$x(t)=x_0+v_{0x}t, \qquad y(t)=y_0+v_{0y}t-\tfrac12 g t^2,$$9 and $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$0 parameters that students infer experimentally, while custom launchers on the “Sources” screen allow users to set mechanism type and angle-stabilizer range. The measurement environment includes a field grid and measuring tape for landing position, a stopwatch for time-of-flight, a histogram of landing distances with adjustable bin width, a toggle between stacked data blocks and solid bars, an Interval Tool for computing the percentage of shots inside a selected range, dynamic overlays of $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$1 and $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$2, and a heat map showing density of launch speed/angle combinations.

The simulation is scaffolded across four screens. “Variability” is used to compare six mystery launchers and inspect raw variability. “Sources” allows the launcher to be “opened up” and custom launchers to be created to probe the physical origins of $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$3 and $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$4. “Measures” is the main screen for visualizing and quantifying mean, $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$5, standard error, and percentages in intervals. “Sampling” is an advanced screen in which samples of size $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$6 are used to plot sampling distributions and standard errors.

Integration with CODAP is implemented through PhET-iO. Every launch is exposed as a JavaScript API event. Before launching, selected setup variables and measured variables are checked in a side panel; on each launch, the API sends the chosen variables as a new row to CODAP’s “Simulation Data” table. CODAP then provides live-updating tables, drag-and-drop plots, linked selection across representations, standard-error displays as bars spanning $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$7, and an optional Gaussian least-squares fit over histograms showing fitted $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$8, $v_{0x}=v_0\cos\theta, \qquad v_{0y}=v_0\sin\theta.$9, and fit uncertainties. If a variable is not checked, it is omitted, thereby mimicking real-world failure to record data.

The three lab activities are structured around a 5-minute open exploration and a Predict–Gather & Analyze–Conclude/Reflect cycle. Lab 1, “Uncover the inner workings of mystery launchers,” emphasizes single-shot measurement, instrument-limited uncertainty, repeated launches, and matching a custom launcher to a mystery launcher’s distribution. Lab 2, “Firing projectiles as far as possible,” treats the dependence of $X$0 and $X$1 on sample size and asks students to justify a one-shot strategy in a “science competition.” Lab 3, “Advanced topics in measurement uncertainty,” uses the small-angle approximation at $X$2, $X$3, and propagates uncertainty via

$X$4

Students then compare the propagated uncertainty to empirical $X$5 and use a Gaussian fit to compute probabilities $X$6. The implementation notes state that, because the noise adds genuine complexity, this PDL is best introduced after students are comfortable with ideal projectile motion.

5. PDL as a data-ingestion and model-library framework in projectile science

Outside introductory mechanics, PDL also appears as a structured entry or cross-section library for projectile-related research data. One example is a PDL entry for momentum distributions of projectile fragments from heavy-ion peripheral collisions at $X$7 MeV/nucleon (Koulouris et al., 2021). The entry reports experimental conditions for $X$8 beams on $X$9 and $t$0 targets, together with MARS separator specifications including momentum acceptance $t$1, angular acceptance $t$2 msr, and mass resolving power $t$3 (FWHM). The momentum-distribution shapes are stated to be well described by Gaussians,

$t$4

with $t$5. The entry also records DIT, CoMD, and GEMINI model details, theoretical cross-section comparisons, and a CSV-formatted table for PDL ingestion. It reports that enhancement of trans-projectile isotopes $t$6 is observed experimentally and is well reproduced by CoMD+GEMINI.

A second example is a PDL-oriented cross-section library for projectile fragmentation (Mallik et al., 2011). The summarized model has three stages: abrasion, disintegration through the Canonical Thermodynamic Model (CTM), and sequential evaporation. Its main methodological novelty is the impact-parameter-dependent temperature ansatz

$t$7

Recommended parameters are $t$8 MeV and $t$9 MeV globally, and $y$00 MeV and $y$01 MeV for best $y$02 versus $y$03 in Sn+Sn. The integration notes explicitly describe how straight-line abrasion geometry, tabulated $y$04, CTM modules, and evaporation modules can be assembled into a PDL cross-section library, while also listing limitations for very light systems and for low-energy regimes.

PDL summaries have also been prepared for strongly non-ideal projectile dynamics. In the dense-suspension impact study, an $y$05 mm iron-steel sphere of mass $y$06 kg is dropped onto a potato-starch suspension layer, and high-speed imaging at $y$07 fps is used to extract $y$08, $y$09, and $y$10 (Egawa et al., 2019). The restitution coefficient is defined as $y$11, and for $y$12 mm the reported value is $y$13; the rebound timescale is $y$14 ms. A Kelvin–Voigt model,

$y$15

is then used to estimate effective modulus and viscosity. The reported typical values are $y$16 Pa, $y$17 Pa·s, and $y$18 Pa·s. The same summary notes that moderate vertical vibration at $y$19 Hz up to $y$20 does not significantly affect the effective viscoelastic response.

In hypervelocity launch research, the PDL-relevant summary concerns an implosion-driven launcher (IDL) capable of launching $y$21 mm ZK60-T5 magnesium projectiles of mass $y$22 g to $y$23 km/s (Huneault et al., 2022). The $y$24 mm-bore launcher has total length $y$25 m, uses helium at $y$26 MPa, and reaches a stagnation pressure of approximately $y$27 GPa. Down-bore velocimetry by Photonic Doppler Velocimetry records $y$28 up to $y$29 km/s in $y$30s for a smaller projectile, while exit-velocity measurements for the $y$31 g projectile give $y$32 km/s and $y$33 km/s on two shots, corresponding to $y$34 km/s. The associated quasi-one-dimensional internal ballistics solver uses conservation equations for mass, momentum, and energy with an ideal-gas EOS for helium, plus non-ideal modules for reservoir expansion and wall ablation. A geometrically scaled $y$35 mm-bore concept is projected to launch $y$36 g projectiles at approximately $y$37 km/s.

6. Common methodological themes and interpretive issues

Across these uses, PDL is consistently associated with direct linkage between measured data and explicit models. In the Tracker workflow, students extract $y$38 and $y$39, fit them, and overlay a dynamic-particle model on the video (Wee et al., 2012). In the Python framework, analytical equations are instantiated as executable code, swept across $y$40 space, and exported as reproducible datasets (Sánchez et al., 9 Jan 2026). In the PhET/CODAP platform, each launch becomes a structured event that can be histogrammed, filtered, grouped, and fitted (Liu et al., 30 Sep 2025). In the heavy-ion, fragmentation, rheology, and hypervelocity summaries, PDL is used to collect equations, metadata, CSV schemas, and experiment–theory comparisons in a form ready for direct inclusion or implementation [(Koulouris et al., 2021); (Mallik et al., 2011); (Egawa et al., 2019); (Huneault et al., 2022)].

The treatment of uncertainty is another cross-cutting theme, but it is not uniform across implementations. In Tracker and the Python framework, the reference problem is largely ideal projectile motion, with attention to fitting, outlier inspection, and parameter extraction. In the PhET/CODAP PDL, variability is deliberately injected through Gaussian noise in $y$41 and $y$42, and finite instrumental precision is part of the learning target. In the nuclear-physics and launcher summaries, uncertainty appears in quoted statistical and systematic errors, fit deviations, separator acceptance, repeatability, and model-experiment residuals. This suggests that PDL is not restricted to either deterministic mechanics or stochastic lab practice; rather, it accommodates both, depending on whether uncertainty is treated as nuisance, signal, or the object of instruction itself.

A common misconception would be to identify PDL exclusively with ideal parabolic motion. The literature does not support that reduction. Some PDL instantiations do indeed focus on the elementary equations of projectile motion and on standard misconceptions such as the supposed need for a horizontal force. Others are explicitly built around noise, standard error, and Gaussian fits, while still others concern multinucleon transfer, dynamically jammed suspension impact, or explosively driven internal ballistics. A plausible implication is that PDL names a methodological family whose unifying feature is the laboratory-style treatment of projectile phenomena through measurable observables, parameterized models, and data export rather than a single physical regime.

In pedagogical terms, the sequence across the educational variants is also notable. The Tracker guide recommends beginning with pure video analysis and then moving to modeling; the Python framework moves from analytical derivation to simulation and parameter-space reasoning; the PhET/CODAP environment adds noise, statistics, and uncertainty after students are comfortable with ideal motion. Read together, these implementations outline a progression from kinematic extraction, to analytical generalization, to statistical inference. This progression is not stated as a universal curriculum, but the published designs indicate a coherent trajectory from deterministic modeling to uncertainty-aware experimentation within the broader PDL concept.