Introduction to Pandas for Physics: Pandas Series & Physical Quantities - Computational Physics Formulation & Simulation

Program 1

Pandas Series & Physical Quantities

Python 3.11 Ready

import pandas as pd
import numpy as np

# Time elapsed in seconds during calorimeter cooling
time_seconds = [0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300]

# Digital thermocouple temperature measurements in Celsius (T_env = 22.0 C)
temp_celsius = [85.4, 79.8, 75.1, 71.0, 67.5, 64.3, 61.6, 59.1, 56.9, 54.8, 53.0]

# 1. Create a Pandas Series with explicit physical time index
cooling_series = pd.Series(data=temp_celsius, index=time_seconds, name="Temp_Celsius")
cooling_series.index.name = "Time_s"

print("=== Calorimeter Cooling Temperature Series ===")
print(cooling_series)

# 2. Vectorized SI Unit Conversion: Celsius -> Kelvin (T_K = T_C + 273.15)
cooling_kelvin = cooling_series + 273.15
cooling_kelvin.name = "Temp_Kelvin"

# 3. Label-based (.loc) vs Position-based (.iloc) inspection
t_query = 120
print(f"\n[Probe Inspection at t = {t_query}s]")
print(f"  Via .loc[{t_query}]:  {cooling_series.loc[t_query]:.2f} deg C ({cooling_kelvin.loc[t_query]:.2f} K)")
print(f"  Initial State (.iloc[0]): {cooling_series.iloc[0]:.2f} deg C")
print(f"  Final State (.iloc[-1]):  {cooling_series.iloc[-1]:.2f} deg C")

# 4. Instantaneous Cooling Rate using finite difference: dT / dt
delta_T = cooling_series.diff()
delta_t = 30.0  # sampling step in seconds
cooling_rate = delta_T / delta_t  # deg C per second
cooling_rate.name = "Cooling_Rate_degC_s"

print("\n=== Experimental Cooling Rate (dT/dt) ===")
print(cooling_rate.dropna().round(4))

# 5. Physical Regime Filtering: Timesteps where temperature exceeds 70.0 deg C
high_temp_trials = cooling_series[cooling_series > 70.0]
duration_s = (len(high_temp_trials) - 1) * 30
print(f"\nHigh-temperature regime (T > 70 deg C): spans {duration_s} seconds ({len(high_temp_trials)} data points).")

Click "Run Code" to execute script and render figures.

Mathematical Problem Formulation

Physical Law & Mathematical Formulation:

In physical calorimetry and experimental thermal physics, the rate of heat exchange between a system and its ambient surroundings is governed by Newton's Law of Cooling:

$$\frac{dT(t)}{dt} = -k \left( T(t) - T_{\text{env}} \right)$$

where $T(t)$ is the instantaneous temperature, $T_{\text{env}}$ is the constant ambient temperature, and $k > 0$ is the characteristic cooling constant determined by the heat capacity and exposed surface area.

Discrete Experimental Sensor Sampling:

In laboratory data acquisition, temperature is sampled at discrete equispaced time intervals $t_i = i \cdot \Delta t$ ($i = 0, 1, 2, \dots, N$). The finite difference rate of cooling is estimated as:

$$\left( \frac{\Delta T}{\Delta t} \right)_i = \frac{T_{i} - T_{i-1}}{t_i - t_{i-1}}$$

In Pandas, a Series maps discrete indices $t_i \in \mathbb{R}$ directly to physical values $T_i \in \mathbb{R}$, enabling vectorized unit transformations ($T_{\text{K}} = T_{^{\circ}\text{C}} + 273.15$) and adjacent difference calculations without explicit iteration loops.

Theoretical Background & Computational Mechanics

1. The 1D Pandas Series in Experimental Physics:

A Pandas Series is a one-dimensional labeled array capable of holding any data type (integers, floating-point measurements, strings). Unlike traditional Python lists or raw NumPy 1D arrays, each data element in a Series is bound to a meaningful physical index (such as timestamps, detector channel IDs, or spatial coordinates).

2. Label-Based vs Position-Based Indexing:

.loc[label]: Retrieves physical readings by exact physical index values (e.g., query sensor state at exactly $t = 120\,\text{s}$).
.iloc[integer_pos]: Retrieves readings by zero-based integer index (e.g., initial condition at .iloc[0] or final equilibrium at .iloc[-1]).

3. Vectorized Temperature Conversion:

Physical calculations frequently require SI unit conversions (such as converting Celsius to Kelvin). Pandas broadcasts scalar addition across the entire Series without requiring explicit for-loops, preserving underlying index metadata and accelerating data processing.

4. Physical Boolean Masking:

By evaluating relational conditions such as cooling_series > 70.0, researchers isolate critical physical regimes—such as determining the duration of high-temperature phases in thermal annealing experiments.

Theoretical Principles & Computational Physics Guide

Pandas Series & Physical Quantities: Computational Physics Modeling & Analysis

Dr. Alorika Chatterjee & Dr. Anirban Shaw Science & Physics Learners Python 3 / NumPy / SciPy

1. Core Principles & Theoretical Framework

Core Concept: Computational formulation and simulation of Pandas Series & Physical Quantities within the study of Introduction to Pandas for Physics.

Algorithmic Translation: Translates theoretical governing equations into clean, discrete Python procedures and verified numerical solvers.

Numerical Verification: Evaluates numerical accuracy, parameter sensitivity, and error bounds for reliable computational results.

2. Mathematical Formulation & Algorithmic Pipeline

Governing computational formulation for Pandas Series & Physical Quantities:

$$ \mathcal{F}_{\text{model}}(\mathbf{x}, t; \mathbf{p}) = 0 \implies \mathbf{y}_{n+1} = \mathcal{S}(\mathbf{y}_n, \Delta t, \mathbf{p}) $$

1. Define Physical Parameters & Boundaries → 2. Execute Numerical Simulation Steps → 3. Evaluate Observables & Plot Results

3. Numerical Mechanics & Implementation Logic

Parameter Initialization: Set physical constants, initial states, and coordinate boundary bounds for Pandas Series & Physical Quantities.
Step Execution: Advance the computational state using optimized vector operations and scientific libraries.
Convergence Control: Monitor stability and ensure simulation metrics remain physically meaningful.

4. Relevant Computational Practice Exercises

Exercise 1

Implement Pandas Series & Physical Quantities and observe how the output responds to variations in primary physical parameters.

Exercise 2

Refine the calculation grid or step size to observe convergence and reduction in numerical approximation error.

Exercise 3

Compare the simulated computational results against an analytical benchmark or limiting physical case.

Standard Literature & References:

Mark Newman, "Computational Physics", University of Michigan (2013).
Hans Petter Langtangen, "A Primer on Scientific Programming with Python", Springer (2016).

Ch. 8.1 Pandas Series & Physical Quantities