Physics Computer Lab II Approach to Thermal Equilibrium

Transcription

1 Physics Computer Lab II Approach to Thermal Equilibrium Developed by É. Flanagan; Version 3 modified by Prof. G. Dugan Fall Introduction Your goal in this project is simulate the approach of a system of particles to thermodynamic equilibrium, for classical particles, fermions, and bosons. For each type of particle, your code will plot the energy distribution of the particles, and you will see the distribution evolve with time from some random initial state to a thermal final state, which will correspond to a Maxwell-Boltzmann distribution, a Fermi-Dirac distribution, or a Bose-Einstein distribution. You will calculate the theoretical distributions at thermal equilibrium, and compare with your simulations. This comparison will allow you to see the fluctuations of a system about the thermal equilibrium state. You will also be able to explore what happens if energy is lost from the system, that is, if its temperature is reduced. As for the first computer project, you will develop several versions of the computer code, each more complicated than the last. This allows code development and testing in stages. A description of what is required of each version is given below. Also there are several exercises to be completed with each version of the code. These should be written up and handed in. You should demonstrate each version of the code to Prof. Flanagan as soon as you have developed it (and before going on to the next version). The first version demonstration is due on Friday Nov 2. The second version demonstration is due on Friday, Nov. 16. The third version demonstration is due due on Friday, Dec Code Version 1: Classical Particles To model the approach to thermal equilibrium, we pick a very simple physical system, consisting of N tot particles, where N tot will be a large integer. The single-particle (non-degenerate) states have energy E equal to any non-negative integer, so the allowed energies are E = 0, 1, 2,.... (1) 1

2 In our code, we will allow any energy up to some maximum energy E max. Exercise 1: For the case of E max, what kind of physical system has these single-particle energy states? To start our simulation, we give each particle the same initial energy E = E i, where E i = 3 (say). This is just some choice of initial state. Our exact choice of initial state is unimportant, you may choose any other initial state you like, as long as the initial average energy per particle is not small compared to 1. To model interactions in our system, we pick any pair of particles at random. We decrease the energy of one of the pair by one unit, and increase the energy of the other (unless the first particle had zero energy, in which case we do nothing). We then repeat this process over and over. This simple energy exchange conserves energy, and has just enough realism in terms of redistributing energy between all the particles to make the system approach thermal equilibrium. To code this simulation in C++, we first need to define some data structures and constants. One possible header file called thermal.h looks like this // header file thermal.h const int Np = 9999; // total number of particles -1 const int Emax = 50; // maximum allowed energy per particle struct state // data type representing a microstate int energy[np+1]; // energy[i] is energy of i th particle ; struct energy_distrib // data type representing energy distribution int n[emax+1]; // n[j] is # of particles with energy j ;... The data type state contains the specification of the system s microstate, the specification of the energy eigenstate of each particle. The data type energy distrib contains the energy distribution of the system, that is, the specification of the number of particles that have energy j for each possible value of j. This is the set of occupation numbers for the system, that is, the configuration. Next, we need to code some functions. We need to be able to compute an energy distribution for a given microstate. To do this, we simply go through all the particles one by one, and for each particle, we add one to the number 2

3 of particles with that energy. computation: Here is a piece of a function to perform this void translate(energy_distrib& ee, state& psi) int i,j; for(;j<=emax;j++) ee.n[j]=0; for(i=0;i<=np;i++) int en = psi.energy[i]; // next check that en >=0 and en <= Emax, otherwise give an error. // Then need to increment the appropriate element of ee.n... The core of the code will be the routine to exchange the energy between a randomly chosen pair of particles. Here is one way of coding this as a routine called shuffle: int shuffle(state& psi) int i1,i2; i1 = (int)((ran2(&random_var)*((float)(np)))); i2 = (int)((ran2(&random_var)*((float)(np)))); if( (i1==i2) (psi.energy[i1]==0)) return(failure); else psi.energy[i1]--; psi.energy[i2]++; return(success); Here we need to define the constants SUCCESS and FAILURE in the header file, just as for the Hartree project. The function shuffle calls a function named ran2, which is random number generator from the Numerical Recipes software package by Press, Teukolsky, Vetterling and Flannery. In order for you to be able to compile your code with calls to ran2, you need to type the Unix command 3

4 cp ~eanna/ran2.o ran2.o You will need to issue this command only once; it copies the object file ran2.o into your directory. Then you will need to issue a compile command like g++ thermal.c GPlot.C ran2.o -o thermal -lm (assuming that you call your program file thermal.c) in order that everything function correctly. You will also need to add the statement float ran2(long *idum); to your header file. In the function shuffle above, the quantity random var is an variable of type long (ie long format integer) which must be input early in the program. It acts as a storage space and also as a seed for the random number generator. See below for the code initializing this variable in the main() routine. If you run the program several times with different input values of random var, you will get different results every time, while if you use the same input value of random var, you will get the same answer every time. Next, we need a routine to print out on the screen the current energy distribution. This is fairly easy, here is such a routine: void show(energy_distrib& ee) cout << endl; cout << "----- Energy distribution " << endl; for(int ;j<=emax;j++) if(ee.n[j]!=0) cout << ee.n[j] << " particles have energy " << j << endl; cout << endl; Finally, we need a routine to make a plot of the log of the number of particles versus energy, say void show plot(energy distrib& ee);, which you can write. The main program should input the value of the seed for the random number generator, initialize the state, then input the number of iterations in the simulation. It should then iterate that many times, print out the energy distribution, and make a plot of the energy distribution. Then, it should once again ask for a number of iterations, and repeat the process over and over. Here is one possible coding. // file thermal.c 4

5 #include <iostream.h> // for input and output #include <math.h> // needed for sqrt() #include <stdlib.h> // for abs() #include "thermal.h" #include "GPlot.h" const int energy_per_particle =3; long random_var; GPlot lnn_vs_e = newgplot(); // plot window int main() state psi; energy_distrib ee; cout << " Enter random seed : "; cin >> random_var; for(int i=0;i<=np;i++) // set up initial state psi.energy[i] = energy_per_particle; // all particles have same energy int nit; for(cout << "Enter number of iterations: "; cin >> nit && nit > 0; cout << "Enter number of " << "additional iterations (or 0): ") int count=0; do if(shuffle(psi)==success) count++; // count only successful shuffles while(count < nit); translate(ee,psi); show(ee); show_plot(ee); 5

6 Finally, let us consider the theoretical Maxwell-Boltzmann distribution that should be achieved in thermal equilibrium. The number of particles n j with energy E j should be given by n j = Ae βe j (2) where β = 1/(k B T ), A is a normalization constant, and E j = j. We can compute the constants β and A in terms of the total number of particles N tot and the total energy of the system E tot using the following equations. (The sums are extended to infinity to simplify the equations; this assumes that the population of the energy levels close to E max is very small). and N tot = E tot = E max n j n j = A e βj = E max = A β E j n j E j n j = A e β A 1 e β (3) je βj e βj = A 1 β 1 e β = A (1 e β ) 2. (4) We can solve Eqs. (3) and (4) for A and β to obtain and A = N 2 tot E tot + N tot (5) [ ] Ntot β = log + 1. (6) E tot Your routine show plot should plot the theoretical distribution (2) as well as the distribution obtained from the simulation. You should also print out the quantities N tot, E tot, A and β. Exercise 2: Run your code in steps of iterations. Watch the initial distribution spread out and then approach a straight line. When you have reached thermal equilibrium, print out a graph, showing both the simulation and the theoretical distribution. How many steps of iterations did it take to reach equilibrium? Why is the right hand side of the graph more jagged than the left? What can you conclude from this about the relative fluctuations of the occupation numbers? 6

7 Exercise 3: Recompile your code with 100 rather than 10,000 particles. Run the code in steps of 100 iterations. Watch the initial distribution spread out and then approach a straight line. Why is the evolution more noisy than before? Why does it not settle down to thermal equilibrium as neatly as before? Does the concept of thermal equilibrium make sense for 100 particles? How about for 10 particles? Exercise 4: Now go back to 10,000 particles, increase E max to 100, and start the simulation with all particles having energy 30 instead of 3. Does is take more or less time to reach equilibrium in this case? Why do you think this is? Why is the graph at equilibrium more jagged than in the first simulation? We can easily modify the code to allow for the possibility of cooling, that is, a loss of energy in the system. In the routine shuffle, if we do not increment psi.energy[i2], then the energy of the system will decrease by one unit every iteration. We wish to be able to turn the cooling on and off; to do this, we can install a switch. In the main program, we add the code cout << Set cooling switch (0=no cooling, 1=cooling) << endl; cin >> cool ; Then, we must pass cool to shuffle, and, if cool =1, do not increment psi.energy[i2]. Exercise 5: Start with 10,000 particles, and an energy per particle of 3. Allow the system to reach thermal equilibrium, with the cooling off. Then, cool for 15,000 iterations, which will reduce the energy by 15,000. Is the system still in thermal equilibrium? Why or why not? How many iterations, with the cooling off, are required to reach thermal equilibrium again? Exercise 6: Start again with 10,000 particles, and an energy per particle of 3. Turn on cooling, and, in steps of 5000 iterations, reduce the energy. Record the values of A and β at each energy. Plot A and β vs. energy. (Note that you are essentially plotting Eqs. (5) and (6)). Is this dependence what you would expect for the physical system identified in Exercise 1? 1.2 Code Version 2: Fermions The essential difference between classical and quantum mechanical particle systems is the nature of the microstates. In the classical state, we had a number of particles, each of which had a well defined energy (the variable psi of type data structure state). The energy distribution giving the number of particles in each energy bin (the variable ee of type data structure energy distrib) was a derived quantity. Specifying the information in ee is not enough to specify the microstate. By contrast, for identical bosons or fermions, the information in the variable ee specifying the number of particles in each energy bin (that is, the configuration) is the complete information determining the microstate. Since the particles 7

8 are identical, there is no meaning to saying which particular particles are in a given energy state. Hence, we will need to delete everything involving the data structure state and the variable psi from the code. For the fermion code, I started by modifying the data type energy distrib to be as follows: struct energy_distrib // data type representing energy distribution double Etot; // total energy of system double Ntot; // total number of particles int n[emax+1]; // n[j] is # of particles with energy j // double n_avg[emax+1]; // averaged distrib // double theory[emax+1]; // theoretical Fermi Dirac distribution // appropriate for Etot and Ntot double B0; // normalization constant double beta; // inverse temperature double Ef; // Fermi energy; This data structure now includes the information about the total energy and total number of particles. The additional entries are discussed below. The first routine to be changed is the routine shuffle. Now, it should act directly on the variable ee rather than psi, since we will not have a variable psi in our fermion code. The interaction process now is as follows. We pick two energy states (not particles) at random, say E i1 = i 1 and E i2 = i 2. If both these states have a non-zero occupation number (ie there are some particles with these energies), then we can reduce the energy of one of the particles with energy i 1 by an amount, and increase the energy of one of the particles with energy i 2 by the same amount. This process will then conserve the total energy. Previously we always took = 1; here we pick it randomly to increase the efficiency of the approach to equilibrium. The way this process changes the occupation numbers is as follows: (i) The number of particles in (or occupation number of) state i 1 is reduced by 1. (ii) The number of particles in state i 1 is increased by 1. This takes care of the particle whose energy is reduced. (iii) The number of particles in state i 2 is reduced by 1, and (iv) the number of particles in state i 2 + is increased by 1. Since the particles are fermions, we must obey the Pauli exclusion principle. Hence, no more than 2 particles can occupy any state (since there are 2 spin states). Thus, we should allow our energy exchange process to occur only if it does not generate any states whose occupation numbers are greater than 2 (or less than 0). The resulting code looks like this (remember that means or in C++): 8

9 int shuffle(energy_distrib& ee) int i1,i2,i1p,i2p,e_exchg; const int Eexchange_max = 100; i1 = (int)((ran2(&random_var)*((float)(emax)))); i2 = (int)((ran2(&random_var)*((float)(emax)))); E_exchg = 1 + (int)((ran2(&random_var)*((float)(eexchange_max)))); i1p = i1 - E_exchg; i2p = i2 + E_exchg; int fermion_disallow = ( (i1p <0 ) (i2p > Emax) (ee.n[i1]<=0) (ee.n[i1p]>=2) (ee.n[i2]<=0) (ee.n[i2p]>=2) (i1 == i2) (i1p == i2p) ); if( fermion_disallow) return(failure); else // perform appropriate operations on the occupation numbers // ee.n[i1], ee.n[i1p], ee.n[i2], ee.n[i2p]... return(success); Next, we need to initialize ee using some initial distribution. The exact choice does not matter. First, we need to set the variable Emax to an appropriate value in the header file. A good value to use here is const int Emax = 2500;. Here is a function initialize that sets up one initial state that gives an interesting visual evolution to equilibrium. void initialize(energy_distrib& ee) for(int ;j<=emax;j++) ee.n[j]=0; for(int i=100;i<1100;i++) if(ran2(&random_var) > 0.7) 9

10 ee.n[i]=1; else ee.n[i]=2; This sets 70% of the states between j = 100 and j = 1100 to have occupation numbers of 2, 30% of those states to have occupation numbers of 1, and the remaining states to have occupation numbers of zero. The next thing that is different in the fermionic case is the relative size of the fluctuations of the occupation numbers. If we plot the actual distribution ee.n obtained after many calls to the routine shuffle, we see a ragged plot where all the values on the y axis are 0, 1, or 2, and the plot jumps back and forwards repeatedly between these values. We do not see the smooth Fermi Dirac distribution we expect, which is n j = 2 Be βj + 1 for some constants B and β. [The factor 2 is the degeneracy factor for 2 spin states]. In version 1 of our code, all the occupation numbers are large, and if a state has occupation number n, then the size of the statistical fluctuations is n, so the fractional fluctuation is 1/ n, which is small for large n. By contrast, for the Fermi-Dirac distribution, the statistical fluctuations are of order n, that is, of order 1. Nevertheless, we can still show that the Fermi-Dirac distribution is a good description of the average occupation numbers by computing an averaged occupation number of the form n j = 1 j 2 j j 2 (7) k=j 1 n j, (8) where j 1 = max(0, j N) and j 2 = min(emax, j + N) for some suitable choice of N. You should write a function to compute the quantity (8) along the lines of void compute_avg_distrib(energy_distrib& ee) // compute averaged energy distribution 10

11 // and store it in ee.n_avg // for(int ;j<=emax;j++) // set ee.n_avg[j] to an average of, for example, 50 // successive values of ee.n[j]... You should modify the routine show plot to plot both the exact and average distributions. An appropriate version of the subroutine main could look something like this int main() energy_distrib ee; initialize(ee); cout << " Fermions - Enter random seed : "; cin >> random_var; int nit; for(cout << "Enter number of iterations: "; cin >> nit && nit > 0; cout << "Enter number of " << "additional iterations (or 0): ") int count=0; do if(shuffle(ee)==success) count++; while(count < nit); show(ee); compute_avg_distrib(ee); show_plot(ee); 11

12 Finally, we want to compare our simulation to the theoretical Fermi-Dirac distribution. This requires that we compute the parameters B and β that enter into the equation (7). For any given value of β, an approximate expression for B can be obtained by approximating the sum over j as an integral. Thus the total number of particles is N tot = E max Emax Hence we can solve for B to obtain 2 Be βj dj 0 Be βj + 1 = 2E max + 2 [ β ln 1 + B 1 + Be βemax ]. (9) B = 1 eβ(n tot/2 E max ). (10) e βn tot/2 1 To obtain the value of β, we need to solve the equation E tot = E max 2j Be βj + 1. (11) This we can do numerically. First, we need to calculate N tot and E tot. Sample code for this is given below: // compute total energy and total number of particles // these will be needed later in the code. ee.etot = 0.0; ee.ntot = 0.0; for(int ;j<=emax;j++) ee.etot += double(j)* double(ee.n[j]); ee.ntot += double( ee.n[j]); Then, we define a function to compute a value of total energy for a given β: double Etotfn(energy_distrib& ee, double beta) // Theoretical total energy as fn of beta, used to find beta. 12

13 ee.beta = beta; ee.b0 = (1.0-exp(beta*(ee.Ntot/2-Emax)))/ ( exp(beta * ee.ntot / 2.0) -1.0); for(int ;j<emax;j++) ee.theory[j] = 2.0 / (1.0 + ee.b0 * exp( ee.beta * (double)(j))); double temp =0.0; for(int ;j<emax;j++) temp += (double)(j) * ee.theory[j]; return(temp); Finally, we need to find the value of β that gives the right total energy. To do this we adopt the shooting code from our Hartree lab that solves for the correct eigenvalue by successive bisection of an interval. To help in initially bracketing the zero of the function, we use the following approximate analytical result for β, which results from a power series expansion of equation (11) in powers of 1 βn tot : β N tot E tot N 2 tot/8 The beginning of a routine to do this is: int findbeta(energy_distrib& ee) double beta1, beta2, beta0; // try to bracket the zero of the function beta0 = ee.ntot/(ee.etot-ee.ntot*ee.ntot/8); beta1 = 0.3 * beta0; beta2 = 10.0 * beta0; double val1 = Etotfn(ee,beta1) - ee.etot; double val2 = Etotfn(ee,beta2) - ee.etot; (12) // check if val1 and val2 have opposite signs. // if not, return FAILURE -- we have failed. // if so, successively chop the interval in two to zero in on the // correct value of beta.... We also need to insert a call to findbeta into the main routine, and in the show plot routine we need to plot the theoretical curve ee.theory as well as the other curves. After plotting the theoretical curve, you should print out the quantities N tot,e tot, B, and β. You should also calculate and print out the 13

14 value of the Fermi energy, given by E F = log(b). (13) β Exercise 7: Run your code in steps of 5000 iterations. Watch the initial distribution approach the theoretical curve. When you have reached thermal equilibrium, print out a graph, showing both the simulation and the theoretical distribution. How many steps of 5000 iterations did it take to reach equilibrium? Exercise 8: Can you suggest another type of averaging, other than averaging over successive energy bins, that would enable us to recover the smooth Fermi Dirac curve from the jagged energy distribution ee.n? Exercise 9: Can you find an initial distribution for which the equilibrium state is to a good approximation a Maxwell-Boltzmann distribution, ie, the classical regime? We can again easily modify the code to allow for the possibility of cooling, that is, a loss of energy in the system. Following the same general procedure as described above for the Maxwell-Boltzmann distribution, modify your code for the Fermi-Dirac distribution to allow for cooling Exercise 10: Start with the initial distribution given at the beginning of this section. Allow the system to reach thermal equilibrium, with the cooling off. Then, cool for a sufficient number of iterations to reduce the energy by 10%. Is the system still in thermal equilibrium? Why or why not? How many iterations, with the cooling off, are required to reach thermal equilibrium again? What happens if you turn the cooling on and try to reduce the energy by half? Exercise 11: Start with the initial distribution given at the beginning of this section. Turn on cooling, and reduce the energy to its minimum in steps. Why is there a minimum energy, and what is it? Record the values of B, E f, and β at each energy. Plot E f and β vs. energy. Do these parameters have the dependence on the total energy you that you would qualitatively expect for a Fermi-Dirac distribution? 1.3 Code Version 3: Bosons Much of the code that you have written for fermions can simply be copied over for bosons. Since, of course, bosons do not obey the exclusion principle, you will have to modify the code in the routine shuffle to allow more than two particles per quantum state. For the initial distribution, you have more freedom than in the fermion case, as any number of particles can occupy a given quantum state. To start, use Emax = 2500, and the same initial distribution as given in version 2 (fermions). Although larger numbers of particles are possible for the initial distribution, the time it takes to reach thermal equilibrium gets progressively longer with more particles. 14

15 For the bosonic case, as for fermions, the relative size of the fluctuations of the occupation numbers is different from the classical case. If we plot the actual distribution ee.n obtained after many calls to the routine shuffle, we see a ragged plot as in the fermionic case, not the smooth Bose-Einstein distribution we expect, which is 1 n j = Be βj (14) 1 for some constants B and β. By contrast with the classical case, for the Bose- Einstein distribution, (as for the Fermi-Dirac distribution), the statistical fluctuations are of order n. Thus, you will still need to compute an averaged energy distribution from the exact distribution; the same code you wrote for fermions will suffice. An appropriate version of the subroutine main could look something like this int main() energy_distrib ee; initialize(ee); cout << " Bosons - Enter random seed : "; cin >> random_var; int nit; for(cout << "Enter number of iterations: "; cin >> nit && nit > 0; cout << "Enter number of " << "additional iterations (or 0): ") int count=0; do if(shuffle(ee)==success) count++; while(count < nit); show(ee); compute_avg_distrib(ee); show_plot(ee); 15

16 Finally, we want to compare our simulation to the theoretical Bose-Einstein distribution. This requires that we compute the parameters B and β that enter into the equation (14). In the Fermi-Dirac case, we used an approximate analytical expression for B, and then found β numerically. For the Bose-Einstein case, the precision of this method will not be adequate. We will want to use this simulation to investigate the phenomenon of Bose-Einstein condensation, in which the distribution function collapses so that almost all the particles are in the lowest quantum state. For this case, we have N tot = E max 1 Be βj 1 1 B 1. (15) We will need to calculate B very precisely, since it is the difference between B and 1 which determines the number of particles in the lowest energy level. We can do this by solving the two equations N tot (B, β) = E max 1 Be βj 1 (16) E tot (B, β) = E max j Be βj 1 (17) numerically, without making any approximations, for B and β. An efficient way to do this is the Newton-Raphson method. This scheme relies on having good starting values for the parameters to be found; let us call the starting values B 0 and β 0. We Taylor expand equations (16) and (17) to first order about B 0 and β 0 : N tot (B, β) = N tot (B 0, β 0 ) + N tot B E tot (B, β) = E tot (B 0, β 0 ) + E tot B These equations can be written in matrix form as ( ) ( ) ( ) δntot M11 M = 12 δb δe tot M 21 M 22 δβ in which δn tot = N tot N tot (B 0, β 0 ) (B B 0) + N tot β (β β 0) (18) (B B 0) + E tot β (β β 0) (19) δe tot = E tot E tot (B 0, β 0 ) 16

17 δb = B B 0 δβ = β β 0 Here N tot and E tot are the numbers we compute from the simulation. The matrix elements are M 11 = N tot B Emax = e β 0j (B 0 e β 0j 1) 2 M 12 = N E tot β = B max 0 je β 0j (B 0 e β 0j 1) 2 M 21 = E tot B Emax = je β 0j (B 0 e β0j 1) 2. M 22 = E E tot β = B max 0 j 2 e β0j (B 0 e β 0j 1) 2 Solving the matrix equations gives the first-order changes in B and β: δb = M 22δN M 12 δe M 11 M 22 M 12 M 21 δβ = M 21δN + M 11 δe M 11 M 22 M 12 M 21 This process can then be iterated, in principle, to any desired level of precision. As mentioned above, the success of this method relies on having good starting values. To obtain these starting values, we can use the technique and code already developed in version 2 of this computer lab. As for the Fermi-Dirac case, for any given value of β, an approximate expression for B can be obtained by approximating the sum over j as an integral. Thus the total number of particles is N tot = E max Emax 0 1 Be βj 1 1 dj Be βj 1 = 1 β ln [ Be βe max 1 B 1 ] E max. (20) 17

18 Hence we can solve for B to obtain B = eβntot e βemax. (21) e βntot 1 For B close to 1, this approximation will often give a value for B which is impossibly small. We know that the minimum value of B will occur when all the particles are in the ground state, i.e., when Eq. (2) is exactly satisfied. Thus, the minimum value of B is known to be B min = N tot. (22) You can thus improve your approximation for B by using equation (21) for B, only if it gives a result greater than B min. Otherwise, use (22) for B. To obtain the value of β, we need to solve the equation E tot = E max j Be βj 1. (23) This we must do numerically. First, we need to calculate N tot and E tot, as we did for the fermion case. Then, we define a function to compute a value of total energy for a given β, and we need to find the value of β that gives the right total energy. This can all be done by simple modifications to the code you developed in version 2. In addition to changing the code to accommodate the Bose-Einstein distribution, the approximate analytical result for β, used for the initial bracketing in findbeta, needs to be changed to: β N tot E tot + N 2 tot/4 (24) The values of B and β returned from findbeta are then input, as starting values, to a new routine refine, which uses the Newton-Raphson method, as described above, to find exact numerical solutions to equations (16) and (17) for B and β. An outline of the code for such a routine is given below: int refine (energy_distrib& ee) double m11,m12,m21,m22,denom1,e0,n0,dn,de,db0,dbeta; int i,j; const int nref=20; // number of refinement steps const double nconv = 0.001; // convergence criterion const double econv=0.001; // convergence criterion 18

19 // calculate theoretical total number of particles (n0) and energy // (e0) n0=0; e0=0; for(i=0; i<=emax; i++) denom1=ee.b0*exp(ee.beta*i)-1; n0 += 1/denom1; e0 += i/denom1; // calculate differences dn and de dn=ee.ntot-n0; de=ee.etot-e0; // begin iteration loop ; while (((dn*dn >= nconv*nconv) (de*de >= econv*econv)) && (j < nref)) m11=0; m12=0; m21=0; m22=0; j++; for(i=0; i<=emax; i++) // calculate m11, m12, m21, m22... // calculate changes db0, dbeta... // update B and beta ee.b0 += db0; ee.beta += dbeta; // calculate new theoretical total number of particles (n0) and energy (e0)... // calculate new values of differences dn and de dn = ee.ntot-n0; de = ee.etot-e0; // success if convergence in less than nref loops if(j < nref) return(success); else return(failure); 19

20 We need to insert a call to findbeta, and then a call to refine, into the main routine. In the show plot routine we need to plot the theoretical curve ee.theory as well as the other curves. Since the distribution will be rapidly varying at low energies, for proper comparison of theory with the averaged distribution, you should calculate and plot an averaged theoretical distribution. You can calculate this from the exact theoretical distribution in the same way that you calculate the averaged simulated distribution from the exact simulated distribution. After plotting the theoretical curves, you should print out the quantities N tot,e tot, B, and β. Exercise 12: Run your code in steps of iterations. Watch the initial (averaged) distribution approach the (averaged) theoretical curve. When you have reached thermal equilibrium, print out a graph, showing both the simulation and the theoretical distribution. How many steps of iterations did it take to reach equilibrium? Exercise 13: Can you find an initial distribution for which the equilibrium state is to a good approximation a Maxwell-Boltzmann distribution, i. e., the classical regime? Is it the same as you found for the Fermi-Dirac case? We can again easily modify the code to allow for the possibility of cooling, that is, a loss of energy in the system. Following the same general procedure as described above for the Maxwell-Boltzmann distribution, modify your code for the Bose-Einstein distribution to allow for cooling. Exercise 14: Start with the initial distribution given at the beginning of this section. Cool for a sufficient number of iterations to reduce the energy by 10%. How many iterations, with the cooling off, are required to reach thermal equilibrium? Reduce the energy by an additional 50%. Is the system still in thermal equilibrium? How many iterations are required to reach equilibrium? Exercise 15: Modify your program to plot the exact, not the averaged, simulated and theoretical distributions, over a small energy range of say Start with the initial distribution given at the beginning of this section. Turn on cooling, and reduce the energy in approximate steps of 10% (You do not need to allow the system to reach equilibrium at each step). Note how the number of particles in the ground state increases dramatically as the energy is reduced. At each energy, record the values of B, β, and the number of particles in the ground state N 0 (which you can read off the graph). Keep reducing the energy in small steps until most of the particles are in the ground state, according to the theoretical distribution. This is the phenomenon called Bose-Einstein condensation. Plot B 1, β, and N 0 vs. energy. If you are very patient, you can turn off cooling at the lowest energy you reach, and run the simulation until it all condenses into the ground state (this will take quite a while). 20