CHAPTER 18 EXPLORING THERMODYNAMICS WITH PYTHON: UNDERSTANDING CARNOT'S THEOREM AND MORE

 Python is a versatile programming language that can be used to simulate and analyze various physical phenomena, including thermal physics & Thermodynamics. Here's a simple example to demonstrate how Python can be used to model thermal conduction:

import numpy as np import matplotlib.pyplot as plt # Parameters L = 1.0 # Length of the rod (m) T_initial = 100.0 # Initial temperature of the rod (°C) T_left = 0.0 # Temperature at the left end of the rod (°C) T_right = 50.0 # Temperature at the right end of the rod (°C) k = 0.01 # Thermal conductivity of the rod (W/m°C) dx = 0.01 # Spatial step size (m) dt = 0.001 # Time step size (s) - reduced from 0.01 t_final = 100.0 # Final simulation time (s) # Number of spatial steps N = int(L / dx) + 1 # Number of time steps M = int(t_final / dt) # Initialize temperature array T = np.full(N, T_initial) # Apply boundary conditions T[0] = T_left T[-1] = T_right # Main loop for _ in range(M): T_old = T.copy() for i in range(1, N-1): # Finite difference equation for heat conduction T[i] = T_old[i] + k * dt / dx**2 * (T_old[i+1] - 2*T_old[i] + T_old[i-1]) # Plotting x = np.linspace(0, L, N) plt.plot(x, T) plt.xlabel('Position (m)') plt.ylabel('Temperature (°C)') plt.title('Temperature Distribution along the Rod') plt.grid(True) plt.show()

OUTPUT:

This code simulates heat conduction along a one-dimensional rod with given boundary conditions and thermal conductivity. The temperature distribution along the rod is calculated using finite difference methods, and the final result is plotted using Matplotlib.

Feel free to modify the parameters and experiment with different scenarios to deepen your understanding of thermal physics!

Modeling thermal convection involves simulating the movement of fluid due to temperature differences. Here's a simple example using Python and the Finite Difference Method to simulate thermal convection in a 2D domain:

import numpy as np

import matplotlib.pyplot as plt

# Parameters Lx = 1.0 # Width of the domain (m) Ly = 1.0 # Height of the domain (m) Nx = 50 # Number of grid points in x-direction Ny = 50 # Number of grid points in y-direction T_hot = 100.0 # Temperature of the hot wall (°C) T_cold = 0.0 # Temperature of the cold wall (°C) nu = 0.01 # Kinematic viscosity (m^2/s) kappa = 0.01 # Thermal diffusivity (m^2/s) dt = 0.001 # Time step size (s) t_final = 1.0 # Final simulation time (s) # Spatial grid x = np.linspace(0, Lx, Nx) y = np.linspace(0, Ly, Ny) dx = Lx / (Nx - 1) dy = Ly / (Ny - 1) # Initialize temperature field T = np.zeros((Ny, Nx)) # Set boundary conditions T[:, 0] = T_hot # Hot wall T[:, -1] = T_cold # Cold wall # Main loop for t in np.arange(0, t_final, dt): T_old = T.copy() for i in range(1, Ny - 1): for j in range(1, Nx - 1): # Finite difference equations for thermal convection T[i, j] = T_old[i, j] + dt * (kappa * (T_old[i, j+1] - 2*T_old[i, j] + T_old[i, j-1]) / dx**2 + kappa * (T_old[i+1, j] - 2*T_old[i, j] + T_old[i-1, j]) / dy**2 + nu * ((T_old[i+1, j] - T_old[i-1, j]) / (2 * dy) + (T_old[i, j+1] - T_old[i, j-1]) / (2 * dx))) # Plotting X, Y = np.meshgrid(x, y) plt.contourf(X, Y, T, cmap='hot') plt.colorbar(label='Temperature (°C)') plt.xlabel('x (m)') plt.ylabel('y (m)') plt.title('Temperature Distribution (Convection)')

plt.show()

OUTPUT:

This code simulates thermal convection in a 2D square domain with a hot wall on the left and a cold wall on the right. It uses the Finite Difference Method to solve the heat equation with additional terms for thermal diffusion and fluid motion (convection). The final temperature distribution is visualized using a contour plot. You can adjust parameters like domain size, boundary temperatures, viscosity, and thermal diffusivity to explore different scenarios.

The First Law of Thermodynamics, also known as the Law of Energy Conservation, states that energy cannot be created or destroyed; it can only be transformed from one form to another or transferred from one place to another. Mathematically, the first law of thermodynamics can be expressed as:ΔU=Q−W

Where:

ΔU is the change in internal energy of the system,

Q is the heat added to the system, and

W is the work done by the system.

Here are two suitable examples to illustrate the First Law of Thermodynamics:

Heating water in a closed container:

Imagine you have a closed container filled with water. If you apply heat to the container by placing it on a stove, the water's temperature will increase. This increase in temperature represents an increase in internal energy

(ΔU) of the water. The heat (Q) from the stove is transferred to the water, causing its temperature to rise. If the container doesn't expand or contract, no work (W) is done, and thus, the change in internal energy (ΔU) is solely due to the heat transfer (Q).

Compression of a gas in a piston-cylinder arrangement:

Consider a gas confined within a piston-cylinder arrangement. If you compress the gas by pushing the piston, you do work (W) on the gas. This work input increases the internal energy (ΔU) of the gas. The compression of the gas also causes its temperature to rise, representing an increase in internal energy. If no heat (Q) is added or lost to the surroundings during this process, then the increase in internal energy (ΔU) is equal to the work (W) done on the gas. In both examples, the total energy change within the system (internal energy plus work done) is equal to the heat added. This principle underscores the conservation of energy, a fundamental concept in thermodynamics. Let's use Python to demonstrate the First Law of Thermodynamics with the examples provided earlier.

Example 1: Heating water in a closed container

# Parameters

heat_added = 5000 # Heat added to the water (Joules)

# Initial state

initial_temperature = 20 # Initial temperature of water (°C)

# Calculate change in internal energy

delta_U = heat_added # Output

print("Example 1: Heating water in a closed container")

print("Change in internal energy (ΔU): {} Joules".format(delta_U))

OUTPUT:

Example 1: Heating water in a closed container
Change in internal energy (ΔU): 5000 Joules

Example 2: Compression of a gas in a piston-cylinder arrangement

# Parameters

work_done = 1000 # Work done on the gas (Joules)

# Initial state

initial_internal_energy = 5000 # Initial internal energy of the gas (Joules)

# Calculate change in internal energy

delta_U = work_done

# Output

print("Example 2: Compression of a gas in a piston-cylinder arrangement")

print("Change in internal energy (ΔU): {} Joules".format(delta_U))

OUTPUT:

Example 2: Compression of a gas in a piston-cylinder arrangement
Change in internal energy (ΔU): 1000 Joules.

In both examples, we calculate the change in internal energy (ΔU) based on the given parameters. In the first example, the change in internal energy is equal to the heat added to the water. In the second example, the change in internal energy is equal to the work done on the gas. These calculations demonstrate the application of the First Law of Thermodynamics using Python. Here are a couple more examples of the First Law of Thermodynamics using Python:

Expansion of a gas against a constant external pressure:

# Parameters

work_done = -2000 # Work done by the gas (Joules)

# Initial state

initial_internal_energy = 3000 # Initial internal energy of the gas (Joules)

# Calculate change in internal energy

delta_U = work_done

# Output

print("Example 3: Expansion of a gas against a constant external pressure")

print("Change in internal energy (ΔU): {} Joules".format(delta_U))

OUTPUT:

Example 3: Expansion of a gas against a constant external pressure

Change in internal energy (ΔU): -2000 Joules

These examples demonstrate different scenarios where the First Law of Thermodynamics applies. In each case, we calculate the change in internal energy (ΔU) based on the given parameters, emphasizing the conservation of energy principle in thermodynamics. The Carnot theorem, also known as Carnot's theorem, is a fundamental principle in thermodynamics that states that no engine operating between two heat reservoirs can be more efficient than a reversible engine operating between the same reservoirs. This theorem provides an upper limit on the efficiency of any heat engine, known as the Carnot efficiency.

Mathematically, the Carnot efficiency (${�}_{�}$) is given by:

${�}_{�}=1-\frac{{�}_{�}}{{�}_{ℎ}}$

Where:

• ${�}_{�}$ is the absolute temperature of the cold reservoir (in Kelvin),
• ${�}_{ℎ}$ is the absolute temperature of the hot reservoir (in Kelvin).

Now, let's explain Carnot's theorem with an example:

Example: Carnot Heat Engine

Consider a heat engine operating between two reservoirs: a hot reservoir at ${�}_{ℎ}=500$ K and a cold reservoir at ${�}_{�}=300$ K.

1. Carnot Efficiency Calculation:

   Using the Carnot efficiency formula, we can calculate the maximum possible efficiency of the engine:

   ${�}_{�}=1-\frac{300}{500}=1-0.6=0.4$

   So, the Carnot efficiency for this engine is 40%.

2. Comparison with Actual Engine Efficiency:

   Let's assume the actual engine's efficiency is 30%. According to Carnot's theorem, this efficiency cannot exceed the Carnot efficiency. Since the actual efficiency is lower than the Carnot efficiency, the engine is operating less efficiently than the theoretical limit imposed by Carnot's theorem.

3. Implications of Carnot's Theorem:

   Carnot's theorem implies that no heat engine, regardless of its design or operating principles, can be more efficient than a reversible engine operating between the same reservoirs. This places an upper limit on the efficiency of all heat engines.

4. Real-World Applications:

   Understanding Carnot's theorem is essential for designing efficient heat engines, such as steam turbines, internal combustion engines, and refrigerators. Engineers use this principle to optimize the performance of these systems and minimize energy waste.

In summary, Carnot's theorem provides a fundamental constraint on the efficiency of heat engines, serving as a cornerstone of thermodynamics and guiding the design of practical engineering systems.

Let's implement the Carnot efficiency calculation and demonstrate Carnot's theorem using Python:

# Function to calculate Carnot efficiency def carnot_efficiency(T_c, T_h): """ Calculate the Carnot efficiency given the temperatures of the cold and hot reservoirs. Arguments: T_c : float Temperature of the cold reservoir (in Kelvin) T_h : float Temperature of the hot reservoir (in Kelvin) Returns: float Carnot efficiency """ return 1 - (T_c / T_h) # Example temperatures T_c = 300 # Temperature of the cold reservoir (in Kelvin) T_h = 500 # Temperature of the hot reservoir (in Kelvin) # Calculate Carnot efficiency carnot_eta = carnot_efficiency(T_c, T_h) print("Carnot Efficiency: {:.2f}%".format(carnot_eta * 100)) # Actual efficiency of an engine (assuming) actual_eta = 0.30 # 30% efficiency # Check if actual efficiency exceeds Carnot efficiency if actual_eta > carnot_eta: print("The actual efficiency exceeds the Carnot efficiency, which violates Carnot's theorem.") else: print("The actual efficiency does not exceed the Carnot efficiency, consistent with Carnot's theorem.")

OUTPUT:

Carnot Efficiency: 40.00%
The actual efficiency does not exceed the Carnot efficiency, consistent with Carnot's theorem.

In this Python code:

• We define a function carnot_efficiency to calculate the Carnot efficiency based on the temperatures of the cold and hot reservoirs.
• We provide example temperatures for the cold and hot reservoirs (300 K and 500 K, respectively).
• We calculate the Carnot efficiency using the carnot_efficiency function and print the result.
• We assume an actual efficiency for an engine (30%) and check whether it exceeds the Carnot efficiency. If it does, we print a message indicating a violation of Carnot's theorem; otherwise, we print a message consistent with Carnot's theorem.