Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Thermostaat

In het vorige werkblad heb je gezien hoe een gas zich gedraagt in een zuiger waarbinnen wordt voldaan aan de wet van behoud van energie. In dat geval geldt p∝αV−kp \propto \alpha V^{-k}, waarbij kk een exponent is die wordt bepaald door de vrijheidsgraden van het gas - in onze simulatie werken we met mono-atomaire gassen in 2D.

We hadden kunnen denken dat we de ideale gaswet zouden kunnen gebruiken. Echter, de temperatuur van het gas verandert door de werking van de zuiger - deze verricht arbeid.

Het meenemen van arbeid dat verricht wordt door, of op, het gas is een eerste uitbreiding die belangrijk is in Thermodynamica. Uitwisseling van energie (toevoegen of afvoeren van warmte) is een tweede uitbreiding. In deze simulatie onderzoeken we die uitbreiding waarbij we warmte aan en af voeren uit het controlevolume. Op die manier kunnen we ook isotherme simulaties doen.

Eerst herhalen we de nodige ingrediënten:

Daarna voegen we de code toe voor het warmtecontact:

En vervolgens

Laden van eerdere code

De pakketten van Python en de constanten voor de simulatie:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from scipy.optimize import curve_fit

#variabele in si eenheden
BOX_SIZE_0 = 10e-9               # Hoogte en breedte startvolume in m
N = 40                         # Aantal deeltjes
V_0 = 410                        # Startsnelheid van deeltjes in m/s
RADIUS = 0.3e-9                     # Straal van moleculen in m
DT = 7.5e-14                         # Tijdstap om geen botsing te missen in s
V_PISTON_0 = -0.1 * V_0      # Startsnelheid van zuiger 
M = 28 * 1.66053873e-27     # Massa van een 'lucht atoom' in kg
k_B = 1.38E-23
# (negatief betekent zowel links als rechts naar binnen gericht)

De klasse voor het gasmolecuul met de interacties:

class ParticleClass:
    def __init__(self, m, v, r, R):
        """ maakt een deeltje (constructor) """
        self.m = m                         
        self.v = np.array(v, dtype=float)  
        self.r = np.array(r, dtype=float)  
        self.R = R

    def update_position(self):
        """ verandert positie voor één tijdstap """
        self.r += self.v * DT 
            
    @property
    def momentum(self):
        return self.m * self.v
    
    @property
    def kin_energy(self):
        return 1/2 * self.m * np.dot(self.v, self.v)
    
def collide_detection(p1: ParticleClass, p2: ParticleClass) -> bool:
    """ Geeft TRUE als de deeltjes overlappen """
    return np.linalg.norm(p1.r - p2.r) < (p1.R + p2.R)


def particle_collision(p1: ParticleClass, p2: ParticleClass):
    """ past snelheden aan uitgaande van overlap """
    m1, m2 = p1.m, p2.m
    delta_r = p1.r - p2.r
    delta_v = p1.v - p2.v
    dot_product = np.dot(delta_r, delta_v)
    # Als deeltjes van elkaar weg bewegen dan geen botsing
    if dot_product >= 0: # '='-teken voorkomt ook problemen als delta_r == \vec{0}
        return
    distance_squared = np.dot(delta_r, delta_r) 
    # Botsing oplossen volgens elastische botsing in 2D
    p1.v -= 2 * m2 / (m1 + m2) * dot_product / distance_squared * delta_r
    p2.v += 2 * m1 / (m1 + m2) * dot_product / distance_squared * delta_r

De randvoorwaarde van het volume. Hierbij is rekening gehouden met een bewegende zuiger die in het vorige werkblad is toegevoegd.

def top_down_collision(particle: ParticleClass):
    global impulse_outward, box_height
    if abs(particle.r[1]) + particle.R > box_height / 2:
        particle.r[1] = np.sign(particle.r[1]) * (box_height/2 - particle.R)
        impulse_outward += abs(particle.momentum[1]) * 2
        particle.v[1] *= -1

def left_right_collision(particle: ParticleClass):
    """ verzorgen van botsingen met wand links en rechts, die als zuiger kunnen bewegen """
    global box_length, v_piston, impulse_outward, work
    if abs(particle.r[0]) + particle.R > box_length / 2:
        particle.r[0] = np.sign(particle.r[0]) * (box_length/2 - particle.R)
        piston_velocity = np.sign(particle.r[0]) * v_piston
        relative_velocity = particle.v[0] - piston_velocity  # stelsel zuiger
        particle.v[0] = -relative_velocity + piston_velocity # stelsel waarnemer
        impulse_outward += 2 * particle.m * abs(relative_velocity)
        work += 2 * particle.m * relative_velocity * piston_velocity

De functies voor het uitvoeren van de functies over de gehele lijst met deeltjes, waarbij we de werking van de zuiger ook hebben meegenomen:

def create_particles(particles):
    """ Leegmaken en opnieuw aanmaken van deeltjes  in lijst """
    global box_length, box_height
    particles.clear()
    for _ in range(N):
        vx = np.random.uniform(-V_0, V_0)
        vy = np.random.choice([-1, 1]) * np.sqrt(V_0**2 - vx**2)        
        x = np.random.uniform(-box_length/2 + RADIUS, box_length/2 - RADIUS)
        y = np.random.uniform(-box_height/2 + RADIUS, box_height/2 - RADIUS)
        particles.append(ParticleClass(m=M, v=[vx, vy], r=[x, y], R=RADIUS))
    
def temperature(particles) -> float:
    temp = 0.0
    kin_energys = [p.kin_energy for p in particles] #E_k van alle  particles berekenen
    avg_kin_energy = np.mean(kin_energys) #gemidelde E_k nemen
    temp = avg_kin_energy/k_B #gemidelde E_k gebruiken om de themperatuur te berekenen, de therm voor het aantal vrijheids graden /2 valt weg, omdat het aantal vreiheidsgraden 2 is
    
    return temp
        
def handle_collisions(particles):
    """ alle onderlinge botsingen afhandelen voor deeltjes in lijst """
    num_particles = len(particles)
    for i in range(num_particles):
        for j in range(i+1, num_particles):
            if collide_detection(particles[i], particles[j]):
                particle_collision(particles[i], particles[j])

def handle_walls(particles):
    """ botsing met wanden controleren voor alle deeltjes in lijst en gemiddeld bepaling druk """
    global pressure, impulse_outward, box_height, box_length   # om pressure buiten de functie te kunnen gebruiken
    impulse_outward = 0.0
    for p in particles:
        left_right_collision(p)
        top_down_collision(p)    
    pressure = 0.95 * pressure + 0.05 * impulse_outward / ((2 * box_length + 2 * box_height) * DT) 
    
def take_time_step(particles):
    """ zet tijdstap voor een lijst deeltjes en verwerk alle botsingen onderling en met wanden """
    global box_length, v_piston
    box_length += 2 * v_piston * DT # zowel links als rechts zuiger
    for p in particles:
        p.update_position()
    handle_collisions(particles)
    handle_walls(particles)

Test code

Voordat we de code aanpassen controleren we eerst of alles het doet. Hiervoor maken we zowel een P,VP,V-diagram als een T,VT,V-diagram (met als toevoeging een P,TP,T-diagram) tijdens de werking van de zuiger. Let op! De eenheden van deze grafiek kunnen niet kloppen omdat er niet in verrekend zit welke constanten jij hebt gekozen.

particles = []
volumes = np.zeros(1000, dtype=float)
pressures = np.zeros(1000, dtype=float)
temperatures = np.zeros(1000, dtype=float)
# times = np.linspace(1, 100, 100)

pressure = 0.0
work = 0.0
box_height = BOX_SIZE_0
box_length = BOX_SIZE_0         # zetten zuiger terug
v_piston = V_PISTON_0
create_particles(particles)     # resetten deeltjes 
for i in range(1000):
    take_time_step(particles)
    volumes[i] = box_length * box_height
    pressures[i] = pressure
    temperatures[i] = temperature(particles)

fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 3))
ax1.set_xlabel('Volume (m^3)')
ax1.set_ylabel('Pressure (Pa)')
ax2.set_xlabel('Volume (m^3)')
ax2.set_ylabel('Temperature (K)')
ax3.set_xlabel('Pressure (Pa)')
ax3.set_ylabel('Temperature (K)')

fig.tight_layout

ax1.plot(volumes, pressures, '-r')
ax2.plot(volumes, temperatures, '-b')
ax3.plot(pressures, temperatures, 'r--')
plt.subplots_adjust(wspace=0.3)      # afstand tussen subplots
plt.show()
<Figure size 1200x300 with 3 Axes>

We zien inderdaad de druk, P∝V−kP \propto V^{-k}, met een exponent k>1k > 1, wat verklaard wordt door de toename van de temperatuur tijdens het proces.

Maar wat gebeurt er wanneer we de temperatuur van het gas constant houden? Als we dat doen kunnen we controleren of de druk inderdaad invers proportioneel is met het volume, zoals de gaswet voorschrijft.

De thermostaat

In de werkelijkheid is de temperatuur van de wand een mate van de amplitude van de trillingen van de deeltjes waaruit de wand bestaat. De wederzijdse overdracht van de energie van die trillingen naar de kinetische energie van de gasmoleculen bepaalt het thermische contact tussen de wanden van het volume en het gas. In ons model bestaat de wand echter helemaal niet uit deeltjes maar hebben we een denkbeeldige lijn getrokken in de ruimte. We moeten daarom een wiskundige truc toepassen om de temperatuur van het gas te beïnvloeden.

Er zijn in de literatuur verschillende van dit soort trucs bedacht. Ze worden een ‘thermostaat’ genoemd. Elk van die type trucs hebben hun voor- en nadelen. In ons geval houden we het simpel: Op het moment dat een gasmolecuul botst met de wand (die een thermisch contact voorstelt), dan schalen we de snelheid van dit molecuul met (de wortel van) de verhouding tussen de veronderstelde temperatuur van de wand en de temperatuur die het gas op dat moment heeft:

v=TwandTdeeltjevv = \sqrt{ \frac{T_{wand}} {T_{deeltje}} }v
(1)

Voor het gemak houden we de linker en rechter wand van het volume als zuiger en maken we het thermische contact aan de onder- en bovenwand.

def top_down_collision(particle: ParticleClass) -> None:
    """ verzorgen van botsingen met wand boven en onder, die als thermostaat kunnen werken """
    global box_height, set_temp, impulse_outward, heat
    if abs(particle.r[1]) + particle.R > box_height / 2:
        temp_factor = (set_temp/temperature(particles)) if set_temp > 0 else 1.0 #T_wand/T_deeltje uit de bovenstaande vergeijking, mocht T_wand kleiner dan 0 zijn wordt de temp_factor 1 om ervoor te zorgen dat de rest van de berekeningen uitgevoerd kunnen worden
        particle.r[1] = np.sign(particle.r[1]) * (box_height/2 - particle.R) #y positie van de particle terugzetten naar voledig binnen de wand, door het + of - teken voor de y positi te vermenigvuldigen met de y positie zodat de particle de wand raakt
        impulse_outward += abs(particle.momentum[1]) * (1 + temp_factor**0.5) #buitenswaardse impulse van 1 deeltje is |p_y_voor| + |p_y_na|, dit resulteert in deze vergelijking
        heat += particle.kin_energy * (temp_factor - 1) #overgedrage warmte van 1 deeltje is E_k_na_ - E_k_voor, dit resulteerd in deze vergelijking
        particle.v *= temp_factor**0.5 #de bovenstaande vergelijking
        particle.v[1] *= -1 #de y richting van de snelheid omdraaien

Met deze nieuwe definitie van de functies, draaien we een simulatie waarin we zowel de temperatuur als de druk plotten als functie van het volume.

Om verdere belasting van de processor tot een minimum te beperken, berekent deze simulatie ook alvast de totale warmte QQ en de totale arbeid WW tijdens het proces. Deze worden opgeslagen in de arrays heats en works. We zullen de resultaten van deze simulatie voor een aantal vervolgstappen gebruiken.

particles = []
N_steps = 5000
volumes = np.zeros(N_steps, dtype=float)
pressures = np.zeros(N_steps, dtype=float)
temperatures = np.zeros(N_steps, dtype=float)
heats = np.zeros(N_steps, dtype=float)
works = np.zeros(N_steps, dtype=float)

pressure = 0.0
work = 0.0
heat = 0.0
box_height = BOX_SIZE_0
box_length = BOX_SIZE_0         # zetten zuiger terug
v_piston = 0.2 * V_PISTON_0
create_particles(particles)     # resetten deeltjes 
set_temp = temperature(particles)

for i in range(N_steps):
    take_time_step(particles)
    volumes[i] = box_length * box_height
    pressures[i] = pressure
    temperatures[i] = temperature(particles)
    heats[i] = heat
    works[i] = work
    if i%500==0:
        print(i)


fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3))
ax1.set_xlabel('Volume (m^3)')
ax1.set_ylabel('Pressure (Pa)')
ax2.set_xlabel('Volume (m^3)')
ax2.set_ylabel('Temperature (K)')
fig.tight_layout

ax1.plot(volumes, pressures, '-r')
ax2.plot(volumes, temperatures, '-b')

plt.subplots_adjust(wspace=0.3)   
plt.show()
0
500
1000
1500
2000
2500
3000
3500
4000
4500
<Figure size 900x300 with 2 Axes>
Tip

Het zelfstandig afschatten van p0 is lastig, maar omdat de relatie tussen pp en VV bekend is, kunnen we wel een eerste stap maken door twee van onze metingen te nemen (p0p_0 en p1p_1 en V0V_0 en V1V_1), delen we die waarden door elkaar en nemen we links en rechts de logaritme krijgen we:

log(p0p1)=log(V0V1)(−n)log(\frac{p_0}{p_1})=log(\frac{V_0}{V_1})(-n)
(2)

Zo hebben we een schatting (ninitn_{init}) voor nn gevonden. Door die waarde nu te substitueren vinden we een initiele guess (ainita_{init}) voor de waarde van aa:

a=p0V0ninita = p_0V_0^{n_{init}}
(3)

Let op het - teken! Waar we nog verder rekening mee moeten houden is dat een verkeerde waarde voor ninitn_{init} kan zorgen voor hele grote fouten in ainita_{init} omdat die exponentieel mee telt. Omdat pp en VV fluctueren door het gering aantal deeltjes kunnen we beter waarden voor sampelen waarbij we een keuze maken moeten tussen grotere sample size voor reduceren van ruis en kleine sampele size om het effect van de zuiger klein te houden:

p0 = np.mean(pressures[100:110])
p1 = np.mean(pressures[N:N+10])
V0 = np.mean(volumes[100:110])
V1 = np.mean(volumes[N:N+10])

n_init = -np.log(p0/p1) / np.log(V0/V1)
a_init = p0 * V0**(-n_init)
p0 = np.mean(pressures[100:110])
p1 = np.mean(pressures[-10:])
V0 = np.mean(volumes[100:110])
V1 = np.mean(volumes[-10:])

n_init = -np.log(p0/p1) / np.log(V0/V1)
a_init = p0 * V0**(n_init)
print(n_init)
print(a_init)
1.124828500353794
3.2363318552972026e-21

def power_law(vol, a, n):
    return a * vol**n    

#your code/answer
var, cov = curve_fit(power_law,volumes,pressures,p0=(a_init,-n_init),maxfev=10000) #curve fit uitvoeren op de bovenstaande vergelijking, n moet negatief zijn, dus staat er een - teken voor n_init
fit_pressures = power_law(volumes,*var)

#volume pressure plot inclusief fit
plt.figure(figsize=(9,5))
plt.plot(volumes,pressures,'r-',label='simulation')
plt.plot(volumes,fit_pressures,'b--',label=f'fit: a = ${var[0]:.1e}\pm{np.sqrt(cov[0,0]):.1e}$, n = ${var[1]:.2e}\pm{np.sqrt(cov[1,1]):.1e}$')
plt.xlabel('Pressure (Pa)')
plt.ylabel('Volume (m^3)')
plt.legend()
plt.show()
<Figure size 900x500 with 1 Axes>

Je ziet dat de exponent van dit (P,V)(P,V)-diagram net niet overeenkomt met de ideale verwachting.

Als je goed kijkt zie je dat de temperatuur voor kleinere volumes een steeds grotere afwijking vertoont.

Al met al lijkt het resultaat van de simulatie er redelijk uit te zien. Maar om een sterkere indicatie te hebben dat de simulatie correct is, moeten we weer een goede test verzinnen om de simulatie te verifiëren. In dit geval kunnen we opnieuw controleren of de simulatie voldoet aan de eerste hoofdwet.

#your code/answer
# 1e hoofdwet: delta U = Q - W, U is bij benadering een lineare functie van T, dus (Q-W)/(delta T) moet gelijk zijn aan een constante
c =  (heats[10:-1] - works[10:-1])/(temperatures[10:-1]-temperatures[0])

times = np.linspace(0,DT*N_steps,N_steps) #time array aanmaken om c ten opzichten van de tijd te plotten

#plot uitvoeren
plt.figure(figsize=(9,5))
plt.plot(times[10:-1],c,'g')
plt.xlabel('$t \mathrm{(s)}$')
plt.ylabel(r'$c \mathrm{(\frac{J}{K})}$')
plt.show()

print(c)
<Figure size 900x500 with 1 Axes>
[5.52e-22 5.52e-22 5.52e-22 ... 5.52e-22 5.52e-22 5.52e-22]

In het boek wordt uitgelegd dat er maar twee vormen van energieoverdracht zijn van een systeem naar de omgeving. Dit kan via warmteoverdracht of via arbeid. Bijzonder is dat deze beide grootheden alleen de snelheid van de moleculen beïnvloeden. Toch zullen we in het volgende werkblad zien dat er een fundamenteel verschil zit in de werking van deze twee macroscopische grootheden.

def top_down_collision(particle: ParticleClass) -> None:
    """ verzorgen van botsingen met wand boven en onder, die als thermostaat kunnen werken """
    global box_height, set_temp_t, set_temp_b, impulse_outward, heat
    if abs(particle.r[1]) + particle.R > box_height / 2:
        index = index_dict[np.sign(particle.r[1])] #bovenwand of onderwand botsing
        temp_factor = (set_temp[index]/temperature(particles)) if set_temp[index] > 0 else 1.0 #T_wand/T_deeltje uit de bovenstaande vergeijking, mocht T_wand kleiner dan 0 zijn wordt de temp_factor 1 om ervoor te zorgen dat de rest van de berekeningen uitgevoerd kunnen worden
        particle.r[1] = np.sign(particle.r[1]) * (box_height/2 - particle.R) #y positie van de particle terugzetten naar voledig binnen de wand, door het + of - teken voor de y positi te vermenigvuldigen met de y positie zodat de particle de wand raakt
        impulse_outward += abs(particle.momentum[1]) * (1 + temp_factor**0.5) #buitenswaardse impulse van 1 deeltje is |p_y_voor| + |p_y_na|, dit resulteert in deze vergelijking
        heat[index] += particle.kin_energy * (temp_factor - 1) #overgedrage warmte van 1 deeltje is E_k_na_ - E_k_voor, dit resulteerd in deze vergelijking   
        particle.v *= temp_factor**0.5 #de bovenstaande vergelijking
        particle.v[1] *= -1 #de y richting van de snelheid omdraaien
particles = []
N_steps = 5000
volumes = np.zeros(N_steps, dtype=float)
pressures = np.zeros(N_steps, dtype=float)
temperatures = np.zeros(N_steps, dtype=float)
heats = np.zeros((N_steps,2), dtype=float)
works = np.zeros(N_steps, dtype=float)

#alle variabele ddie te maken hebben met heat zijn een lijst waar de eerste waarde corespondeerd met de bovenwand en de 2e waarde met de onderwand
pressure = 0.0
work = 0.0
heat = [0.0,0.0]
box_height = 4*BOX_SIZE_0 #4 keer de hoogte
box_length = BOX_SIZE_0         # zetten zuiger terug
N = 160 #4 keer zoveel deeltjes
v_piston = 0 #zuiger stilzetten
create_particles(particles)     # resetten deeltjes 
set_temp = [1.5*temperature(particles), 0.5*temperature(particles)] #verschillende themperaturen boven en onderwand
index_dict = {1:0,-1:1} #positief komt overeen met index 0 en dus bovenwand, negatief komt overeen met index 1 en dus onderwand

for i in range(N_steps):
    take_time_step(particles)
    volumes[i] = box_length * box_height
    pressures[i] = pressure
    temperatures[i] = temperature(particles)
    heats[i,0] = heat[0]
    heats[i,1] = heat[1]
    works[i] = work
    if i%500==0:
        print(i)


fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3))
ax1.set_xlabel('Volume (m^3)')
ax1.set_ylabel('Pressure (Pa)')
ax2.set_xlabel('Volume (m^3)')
ax2.set_ylabel('Temperature (K)')
fig.tight_layout

ax1.plot(volumes, pressures, '-r')
ax2.plot(volumes, temperatures, '-b')

plt.subplots_adjust(wspace=0.3)   
plt.show()
0
500
1000
1500
2000
2500
3000
3500
4000
4500
<Figure size 648x216 with 2 Axes>
#heat transfer van de boven en onderwand plotten
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3))
ax1.set_xlabel('Time (s)')
ax1.set_ylabel('Heat (J)')
ax2.set_xlabel('Time (s)')
ax2.set_ylabel('Heat (J)')
ax1.set_title('Top')
ax2.set_title('Botom')
fig.tight_layout

ax1.plot(times, heats[:,0], '-r')
ax2.plot(times, heats[:,1], '-b')

plt.subplots_adjust(wspace=0.3)   
plt.show()
<Figure size 648x216 with 2 Axes>
# heat transfer berekenen
Q = (heats[:,0] - heats[:,1])/2

def heat_func(t,l_g):
    return l_g*(set_temp[0]-set_temp[1])*t

var, cov = curve_fit(heat_func, times, Q) #fiten om lambda te vinden

Q_fit = heat_func(times, *var)

# heat transfer en fit plotten
plt.figure(figsize=(9,5))
plt.plot(times,Q,'g',label='sim')
plt.plot(times,Q_fit,'r--', label=f'lambda = {var[0]:.3e} +/- {np.sqrt(cov[0,0]):.0e} W/K')
plt.xlabel('$t \mathrm{(s)}$')
plt.ylabel('$Q \mathrm{(J)}$')
plt.legend()
plt.show()
<Figure size 648x360 with 1 Axes>
VSC
Arbeid Excellent
VSC
Entropie 🌶