Population distribution,

Before looking at sample averages, the “ground truth” of our data is built. In this example, population has weight with a probability density distribution , resulting as an example from a factory production line for pens. While the machine produces a standard spread, a quality control process rejects any pen weighing less than a specific threshold (e.g., 10g).

The resulting distribution of this process is a left-truncated Gaussian: it features a sharp “cliff” on the left and a natural decay on the right. Clearly, the individual items in this population do not follow a standard bell curve.

Remark. Different processes may produce individuals following different probability densities. As an example, there’s a bimodal distribution already implemented: just open this file in Colab, clicking on the button “Open in Colab”, under the Code Links, uncomment those lines and run this script.

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)

# Create a non-Gaussian population:

#> Left truncated Gaussian
# 1. Standard Gaussian
mu_factory = 10.5
sigma_factory = 0.4
raw_production = np.random.normal(mu_factory, sigma_factory, 15000)

# 2. Apply Quality Control: Cut everything below 9.2g
threshold = 10.
population = raw_production[raw_production >= threshold]

pop_size = len(population)

"""
#> Bimodal distribution

# 40% are "Light" pens (10g), 60% are "Heavy" pens (15g)
pop_size = 100_000
group1 = np.random.normal(10, 0.8, int(pop_size * 0.4))
group2 = np.random.normal(15, 1.5, int(pop_size * 0.6))
population = np.concatenate([group1, group2])
"""

plt.figure(figsize=(5, 5))
plt.hist(population, bins=30, color='lightgray', edgecolor='gray', alpha=0.7)
plt.axvline(np.mean(population), color='red', linestyle='--', label=f'Mean: {np.mean(population):.2f}')
plt.title(f"Physical Population $p(x)$: Weights of {pop_size} Individual Pens")
plt.xlabel("Weight (g)")
plt.ylabel("Count")
plt.legend()
plt.show()

The fallacy: “more samples make the distribution Gaussian”

A common misunderstanding is that collecting more data will “fix the distribution” and make it look normal. This is not true! Sampling individuals from the population, as the number of individuals in a sample increases they follow the very same distribution of the whole population.

As the sample size is increased from to individuals, the histogram simply becomes a more accurate representation of the truncated population with probability density . The “cliff” of the left-truncated distribution remains vertical. This shows that a large dataset of individual measurements does not “naturally become Gaussian” if the underlying population is not.

sample_sizes = [50, 500, 5000]

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

for i, n in enumerate(sample_sizes):
    sample = np.random.choice(population, size=n)
    axes[i].hist(sample, bins=30, color='salmon', edgecolor='black', alpha=0.8)
    axes[i].set_title(f"Sample of {n} Individuals")
    axes[i].set_xlabel("Weight (g)")

plt.suptitle("", fontsize=16)
plt.tight_layout()
plt.show()

Correct application of the central limit theorem

The Central Limit Theorem (CLT) makes a very specific claim: it is not the individuals that become Gaussian, but the sum (or sample average, ) of those individuals,

To see this, we take many random “samples”, each of individuals and calculate the average weight for each cluster.

This process is repeated for different values of . As the number increases, the sample average tends to a random variable with a Gaussian probability distribution, centered at the population mean , and with variance that decreases with , i.e. for “large”

being the (finite) variance of the population .

def plot_sampling_distribution(pop, n_values, iterations=1000):
    fig, axes = plt.subplots(1, len(n_values), figsize=(18, 5))
    
    for i, n in enumerate(n_values):
        # The CLT step: calculate the mean of 'n' random pens, 2000 times
        sample_means = [np.mean(np.random.choice(pop, size=n)) for _ in range(iterations)]
        
        # Plotting the means
        axes[i].hist(sample_means, bins=30, color='skyblue', edgecolor='navy', density=True, alpha=0.7)
        
        # Add a theoretical normal curve for comparison
        mu = np.mean(pop)
        sigma_mean = np.std(pop) / np.sqrt(n)
        x = np.linspace(min(sample_means), max(sample_means), 100)
        p = (1 / (sigma_mean * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma_mean)**2)
        axes[i].plot(x, p, color='darkblue', linewidth=2, label='Normal Dist.')
        
        axes[i].set_title(f"Distribution of Means (n={n})")
        axes[i].set_xlabel("Average Weight (g)")
        if i == 0: axes[i].set_ylabel("Probability Density")

plot_sampling_distribution(population, n_values=[2, 5, 10, 30])
plt.tight_layout()
plt.show()

Links and references

• Sampling, sampling average, central limit theorem, Gaussian and Student’s -distribution, in Introduzione alla programmazione, al calcolo scientifico e alla statistica
• …

The physics

Differential equations. Euler equations are the local (differential) form of three fundamental principles of classical mechanics:

1. conservation of mass
2. second principle of Newtonian mechanics, or balance of momentum
3. first principle of Thermodynamics, or balance of total energy

in the limit of negligible viscosity and heat conduction, supplemented with proper:

• constitutive equations describing the behavior of the medium of interest,
• boundary conditions
• initial conditions.

Differential equations hold only in regions of space where the functions involved are continuous and sufficient regular for the derivativesi appearing in the equations to exist.

Neglecting diffusive terms (viscous stress and heat conduction), Navier-Stokes equations become Euler equations. While Navier-Stokes equations contain second-order derivatives in space (e.g. the Laplacian of the velocity in viscous stress, and the Laplacian of temperature in heat conduction flux), Euler equations are first orde. While Navier-Stokes equations are not prone to produce discontinuous solutions, discontinuities (like shock waves) naturally arises in Euler equations.

Fields involved in Euler equations may be not continuous across a discontiuity. Thus, across a discontinuity, the differential form of the equations is likely to fail, while integral equations are still valid (not having the same regularity assumptions required by differential equations, to be derived from the integral equations, namely no divergenvce theorem is required).

Integral equations. For a control volume at rest

Integral equations for an arbitrary volume can be written Using Reynolds’ transport theorem. These equations provides:

• jump conditions across discontinuities
• arbitrary Lagrangian Eulerian description of the problem, that can be useful for moving domains

The mathematical features

Euler equations are an example of a non-linear hyperbolic system of equations. In this section, general hyperbolic problems

are introduced and their features are discussed.

todo

• conservative and convective form of the differential equations

• spectral decomposition of the convection matrix

• origin of speed of sound

• velocity of propagation of the info

• continuous solutions

• discontinuous solutions (speed of the shock and Rankine-Hugoniot conditions)

• infinite non-physical solutions; entropy condition to select the physical solution among them

• Riemann problem: definition; solution of the Riemann problem is used in physics-based numerical schemes

The numerical realization

The Finite Volume Method (FVM) is the natural choice for hyperbolic conservation laws because it is derived directly from the integral form of the governing equations. Rather than approximating derivatives at discrete points, FVM enforces the balance of fluxes across the boundaries of discrete control volumes (cells).

In its simplest form, the numerical solution is represented as piecewise constant, where physical fields are averaged within each cell. The core challenge in developing an FVM scheme lies in the design of the numerical flux at cell interfaces. This flux must be carefully constructed not only for stability but to act as a mathematical “selection principle,” ensuring that the captured solution is the unique physical solution (the entropy solution) among the infinite set of weak solutions allowed by the mathematics of hyperbolic PDEs.

Godunov scheme treates the jump between fields in two adjacent cells as a local Riemann problem. The scheme solves the Riemann problem to find the state at the boundary, and uses that state to compute the numerical flux. Riemann problem is a non-linear problem that could be computationally expensive to solve at every time-step for every cell interface. To reduce the computational cost, Roe method intoruces a local linearization of the problem at each interface. Convection matrix is evaluated on the Roe intermediate state, and its spectrum is used to build an upwind scheme that, combined with entropy fix schemes, introduces enough numerical diffusion to select the physical solution.

todo - CFL condition - theorems about flux: stability vs. accuracy - high-order schemes - …

Natural modes

Many structural problems are governed by a differential problem, whose discret(ized) counterpart is a second order dynamical system,

supplied with the proper conditions on the state , like initial values of the function and its first derivative for Cauchy problems (or initial value problems),

String

#> Some libraries
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt

#> Bode diagram of the natural modes

#> Parameters of the system (non-dimensional)
m, N0, b = 1., 1., np.pi
c = np.sqrt(N0/m)
xi = .02

n_modes = 30
i_modes = np.arange(1, n_modes+1)
omegas = 10.**np.linspace(-.5, 1.5, 1000)

fig, ax = plt.subplots(2,1, figsize=(5, 5))

for i_mode in i_modes:
    #> Mode parameters
    k_n = i_mode * np.pi / b
    omega_n = k_n * c
    xi_n = xi

    #> Continuous-time TF (no dt is given as a third argument in signal.TransferFunction)
    # defined with numerator and denominator
    num = np.array([1, 0, 0]) * (-1)**(i_mode+1) * 2. / ( np.pi * i_mode )
    den = np.array([1, 2*xi_n*omega_n, omega_n**2])
    sys = signal.TransferFunction(num, den)

    #> Evaluation of magnitude and phase of the TF of the LTI system sys
    # mag is in dB i.e. |G|_{dB} = 20 log_10{|G|}se
    w, mag, phase = signal.bode(sys, omegas)

    #> Plot
    ax[0].semilogx(omegas, mag  , lw=.7)
    ax[1].semilogx(omegas, phase, lw=.7)

G_ticks = 20 * np.arange(-4,3)
ax[0].set_yticks(G_ticks)
ax[0].set_xlim(omegas[0], omegas[-1]);  ax[0].grid()
ax[0].set_ylim(G_ticks[0], G_ticks[-1])
ax[1].set_xlim(omegas[0], omegas[-1]);  ax[1].grid()
ax[0].set_ylabel('$|G|_{dB}$')
ax[1].set_xlabel('$\Omega$')
ax[1].set_ylabel('$\phi$')

Text(0, 0.5, '$\\phi$')

Linear elastic problem

Equilibrium conditions

Compatibility conditions