Question

Suppose we have measured the oscillation period \(T\) of a simple pendulum with a mass \(m\) at the end of a massless rod of length \(L\). We have varied \(L\) and recorded the corresponding \(T\) value. The measurements are found in a file src/files/pendulum. dat, containing two columns. The first column contains \(L\) values and the second column has the corresponding \(T\) values. Load the \(L\) and \(T\) values into two arrays. Plot \(L\) versus \(T\) using circles for the data points. We shall assume that \(L\) as a function of \(T\) is a polynomial. Use the NumPy utilities polyfit and poly1d, as explained in Exercise 6.4, and experiment with fitting polynomials of degree 1,2 , and 3. Visualize the polynomial curves together with the experimental data. Which polynomial fits the measured data best? Name of program file: fit_pendulum_data.py.

Short answer

Visual inspection usually determines the best fit; degree 2 or 3 often closely match oscillation data.

Step-by-step solution

Import Necessary Libraries

First, we need to import the libraries required for the task. We'll use NumPy for numerical operations and polynomial fitting, and Matplotlib for plotting. ```python import numpy as np import matplotlib.pyplot as plt ```

Load Data from the File

We need to read the data from the file `src/files/pendulum.dat`. Assuming the file is formatted with two space-separated columns, we can use NumPy to load the data into two arrays, `L` for lengths and `T` for periods. ```python data = np.loadtxt('src/files/pendulum.dat') L = data[:, 0] T = data[:, 1] ```

Plot the Experimental Data Points

Plot the data points to visualize the relationship between `L` and `T`. Use circles to represent data points on the plot. ```python plt.scatter(L, T, c='blue', label='Data Points') plt.xlabel('Length (L)') plt.ylabel('Period (T)') plt.title('Pendulum Length vs Period') plt.grid(True) ```

Fit Polynomial of Degree 1

Use NumPy's `polyfit` to fit a polynomial of degree 1 (linear fit) to the data. Then, generate a polynomial function using `poly1d` and compute the corresponding values. ```python coeffs_1 = np.polyfit(L, T, 1) poly_1 = np.poly1d(coeffs_1) plt.plot(L, poly_1(L), label='Degree 1', linestyle='--') ```

Fit Polynomial of Degree 2

Similarly, fit a polynomial of degree 2 (quadratic fit) to the data, and plot the resulting polynomial. ```python coeffs_2 = np.polyfit(L, T, 2) poly_2 = np.poly1d(coeffs_2) plt.plot(L, poly_2(L), label='Degree 2', linestyle='-.') ```

Fit Polynomial of Degree 3

Repeat the previous process for a polynomial of degree 3 (cubic fit). ```python coeffs_3 = np.polyfit(L, T, 3) poly_3 = np.poly1d(coeffs_3) plt.plot(L, poly_3(L), label='Degree 3', linestyle=':') ```

Analyze and Display the Best Fit

After plotting the data and polynomial fits, visually inspect which polynomial curve follows the data points closely. Add a legend and show the complete plot. ```python plt.legend() plt.show() ```

Determine the Best Fit

Based on the visualization, typically the polynomial with the smallest error in fitting (i.e., the curve that best 'traces' the data points) is considered the best fit. The user should analyse which graph fits best visually or use additional statistical measures like RMSE if required.

Key concepts

Data Analysis

Data analysis is a vital process of inspecting, cleaning, and modeling data with the goal of discovering useful information, forming conclusions, or supporting decision-making.
In the context of our pendulum problem, data analysis involves extracting meaningful insights from the recorded oscillation period and rod length data.
By loading and examining these measurements, we can make interpretations on the nature of their relationship. This type of data analysis is valuable in fields like physics, where understanding physical laws through experimental data is fundamental. Data analysis helps in identifying underlying patterns and verifying scientific theories.

Polynomial Fitting

Polynomial fitting is a type of curve fitting where a polynomial equation is used to model the relationship between variables.
When analyzing the pendulum data, we assumed the period as a polynomial function of the rod length.
The usage of polynomial fitting allows for flexible modeling. This is because it can represent linear, quadratic, cubic, or even higher-order relationships, by adjusting the polynomial's degree.

• Degree 1: Represents a linear relationship.
• Degree 2: Represents a quadratic curve.
• Degree 3: Represents a cubic pattern.

Fitting these polynomials to our data involves finding the coefficients that minimize the discrepancy between the observed data and the model's predictions.

Visualization

Visualization involves the creation of visual representations of the data and its analysis results.
This is a crucial step in our polynomial fitting exercise, as it allows us to actively interpret the relationship between the pendulum's length and its oscillation period.
Plotting the data using circles provides an initial overview of how the two variables relate. Then, overlaying the polynomial curves lets us visually compare how well each model aligns with the experimental data. Visualization not only clarifies data insights but also facilitates communication of findings to others who can engage visually without requiring a deep dive into the raw numerical data.

NumPy

NumPy is a powerful Python library for numerical computing, which is core to executing many data science tasks.
In our pendulum problem, NumPy is used to handle data loading and perform the polynomial fitting tasks seamlessly.
Key features offered by NumPy that were utilized include:

• Load data from text files: `np.loadtxt()` function simplifies reading structured data directly into arrays.
• Polynomial Fitting: Functions like `np.polyfit()` perform sophisticated polynomial fitting with ease.
• Creating polynomial functions: `np.poly1d()` is used to create a polynomial object which can be evaluated at various points.

NumPy's contribution to managing and manipulating arrays form the backbone of efficient data analysis in Python.

Matplotlib

Matplotlib is a widely-used Python library for creating static, animated, and interactive visualizations.
In our exercise with the pendulum's data, it plays an essential role in plotting both the experimental points and the fitted curves of various polynomial degrees.
Some key aspects of Matplotlib used in this task include:

• Creating scatter plots: `plt.scatter()` was used to visualize each length and period data point clearly.
• Plotting lines: Functions like `plt.plot()` enabled the drawing of polynomial curves that indicate trends within the data.
• Customization: Adding titles, labels, and legends enriches the plot making it informative.

Matplotlib makes it straightforward to reveal the narrative hidden within the data through visualization.