Pelliccione M., Lu T.-M. Evolution of Thin Film Morphology: Modeling and Simulations
Подождите немного. Документ загружается.
A.4 Power Spectral Density Functions 171
2+1 Dimensions
• Self-affine exponential model:
R(r)=exp
−
r
ξ
2α
, (A.100)
P (k)=
w
2
ξ
2
4πα
∞
j=0
Γ
j+1
α
(j!)
2
−
k
2
ξ
2
4
j
. (A.101)
• Self-affine exponential model (α =1):
R(r)=exp
−
r
ξ
2
, (A.102)
P (k)=
w
2
ξ
2
4π
exp
−
k
2
ξ
2
4
. (A.103)
• Self-affine K -correlation model:
R(r)=
α
2
α−1
Γ(α +1)
r
ξ
√
2α
α
K
α
r
ξ
√
2α
, (A.104)
P (k)=
w
2
ξ
2
2π
1+
k
2
ξ
2
2α
1+α
. (A.105)
• Mounded exponential model:
R(r)=exp
−
r
ξ
2α
J
0
2πr
λ
, (A.106)
P (k)=
w
2
ξ
2
8π
2
α
∞
j=0
Γ
j+1
α
(j!)
2
−
πkξ
2
aλ
j
2π
0
[1 − a cos θ]
j
dθ,
where a =
4πλk
k
2
λ
2
+4π
2
. (A.107)
• Mounded exponential model (α =1):
R(r)=exp
−
r
ξ
2
J
0
2πr
λ
, (A.108)
P (k)=
w
2
ξ
2
4π
exp
−
4π
2
+ k
2
λ
2
ξ
2
4λ
2
I
0
πkξ
2
λ
. (A.109)
172 A Mathematical Appendix
• Mounded K -correlation model:
R(r)=
α
2
α−1
Γ(α +1)
r
ξ
√
2α
α
K
α
r
ξ
√
2α
J
0
2πr
λ
, (A.110)
P (k)=
w
2
ξ
2
2πΓ(α +1)
1+
k
2
ξ
2
2α
+
2π
2
ξ
2
αλ
2
1+α
∞
j=0
Γ(2j + α +1)
(j!)
2
a
2
4
j
,
where a =
4πξ
2
λk
2αλ
2
+ k
2
ξ
2
λ
2
+4π
2
ξ
2
. (A.111)
• Mounded K-correlation model (α =1):
R(r)=
r
√
2
ξ
K
1
r
√
2
ξ
J
0
2πr
λ
, (A.112)
P (k)=
w
2
ξ
2
2π
1+
2π
2
ξ
2
λ
2
+
ξ
2
2
k
2
1+
2π
2
ξ
2
λ
2
+
ξ
2
2
k
2
2
−
2πξ
2
λ
k
2
3/2
. (A.113)
B
Euler’s Method Implementation
The following is a C++ implementation of Euler’s method to compute the
solution to the partial differential equation
∂h(x, t)
∂t
= ∇
2
h(x, t)+η(x, t), (B.1)
in one spatial dimension with cyclic boundary conditions and Gaussian dis-
tributed noise. A representative graph of the surface profile is included in Fig.
B.1, and the evolution of the interface width is pictured in Fig. B.2.
#include <iostream>
#include <fstream>
#include <cmath>
using namespace std;
float* h; //Stores h(x) at the current time
float* h_old; //Stores h(x) at the previous time iteration
float delta_x = 1;
float delta_t = 0.001;
int N = 5000; //Total length of domain = N*delta_x
int T = 10000; //Total length of time = T*delta_t
float D = 1; //Variance of the noise
float mean = 0;
float roughness = 0;
float laplacian(int j) //Computes the Laplacian of h(x)
{
if(j == 0) //Cyclic boundary conditions
return (h[j+1]-2*h[j]+h[N-1])/((delta_x)*(delta_x));
else if(j == N-1) //Cyclic boundary conditions
174 B Euler’s Method Implementation
return (h[0]-2*h[j]+h[j-1])/((delta_x)*(delta_x));
else
return (h[j+1]-2*h[j]+h[j-1])/((delta_x)*(delta_x));
}
float noise()
{
//Box-Muller transform to generate Gaussian random
//variables with mean zero and variance one
float x1, x2, k, y;
do {
x1 = 2 * rand()/((float)RAND_MAX) - 1;
x2 = 2 * rand()/((float)RAND_MAX) - 1;
k = x1*x1 + x2*x2;
} while ( k >= 1.0 );
k = sqrt((-2.0*log(k))/k);
y=x1*k;
return y;
}
int main()
{
h = new float[N];
h_old = new float[N];
//Seed the random number generator
srand((unsigned)time( NULL ));
ofstream stats;
stats.open("stats.txt");
for(int i = 0; i < N; i++)
{
h[i] = 0;
}
for(int i = 0; i < N; i++)
{
h_old[i] = h[i];
}
//Iterate through time steps
for(int k = 0; k < T; k++)
B Euler’s Method Implementation 175
{
//Iterate through position steps
for(int j = 0; j < N; j++)
{
//Euler’s Method
h[j] = h_old[j]+
delta_t*(laplacian(j)+sqrt( 2*D/
((delta_t)*(delta_x)*(delta_x)) )*noise());
}
//Iterate to next time step
for(int i = 0; i < N; i++)
{
h_old[i] = h[i];
}
mean = 0;
for(int i = 0; i < N; i++)
{
mean += h[i];
}
mean = mean / N;
roughness = 0;
for(int i = 0; i < N; i++)
{
roughness += (h[i]-mean)*(h[i]-mean);
}
roughness = sqrt(roughness / N);
stats << k << " " << mean << " "
<< roughness << endl;
}
ofstream output; //Output the results
output.open("result.txt");
for(int i = 0; i < N; i++)
{
176 B Euler’s Method Implementation
output << i << " " << h[i] << endl;
}
return 0;
}
B Euler’s Method Implementation 177
Substrate Position (lattice units)
Surface Height ( ) (lattice units)
0 20 40 60 80 100
-4
-2
0
2
4
Fig. B.1. An example surface profile from the included code to model the Edwards–
Wilkinson equation in one dimension. The position step size is ∆x = 1, and the
Gaussian noise has a variance D =1.
Deposition Time (arb. units)
Interface Width (lattice units)
10
-3
10
-2
10
-1
10
0
10
1
10
-1
10
0
¯ = 0.25 ± 0.03
Fig. B.2. Interface width evolution of the Edwards–Wilkinson equation in one
dimension calculated from the included code. The interface width evolves with an
exponent β =0.25 ± 0.03, consistent with the discussion in Sect. 5.1.2 for d =1.
C
Small World Model Implementation
The following is a C++ implementation of the small world model discussed
in Chap. 6. This code simulates a small world network model with negative
(shadowing) links between heights separated by a predetermined distance,
λ
0
= 10 lattice units. This code can be modified to simulate surface growth
under reemission and geometrical shadowing links as discussed in Chap. 6.
#include <iostream>
#include <cmath>
#include <fstream>
#include <time.h>
#include <string>
using namespace std;
const int N = 128;
float * Surface [N];
float * SurfaceNew [N];
float * links[N];
string filenm;
float D,deltat;
float deltax = 1;
float h(int x,int y)//Surface height
{
while(x<0){x=x+N;}
while(x>N-1){x=x-N;}
while(y<0){y=y+N;}
while(y>N-1){y=y-N;}
180 C Small World Model Implementation
return Surface[x][y];
}
float del2xy(int x, int y) //Laplacian
{
return ( (h(x+1,y)+h(x-1,y)+
h(x,y+1)+h(x,y-1)-
(float)4*h(x,y) )/(deltax)*(deltax) );
}
float sw(int x, int y)
//Small world links for surface point at (x,y)
{
float growth = 0;
int shad_len = 10;
//Shadowing length, or lambda_0
//Heights are linked if separated by
//a distance less than shad_len
for(int k=-shad_len; k<=shad_len; k++)
{
for(int l=-shad_len; l<=shad_len; l++)
{
if( sqrt(k*k+l*l)<= shad_len)
{
growth += -(h(x+k,y+l)-h(x,y));
//Link strength is negative
}
}
}
return growth;
}
float noise()
{
//Box-Muller transform to generate Gaussian random
//variables with mean zero and variance one
float x1, x2, k, y;
do {
x1 = 2 * rand()/((float)RAND_MAX) - 1;
x2 = 2 * rand()/((float)RAND_MAX) - 1;
C Small World Model Implementation 181
k = x1*x1 + x2*x2;
} while ( k >= 1.0 );
k = sqrt((-2.0*log(k))/k);
y=x1*k;
return y;
}
void set_links() //Normalize link strength
{
float sum = 0;
float num = 0;
for(int i = 0; i < N; i++)
{
for(int j = 0; j < N; j++)
{
num = sw(i,j);
links[i][j]=num;
//Find sum of link strengths
sum += abs(num);
}
}
if(sum == 0) return;
//Normalize link strength
for(int i = 0; i < N; i++)
{
for(int j = 0; j < N; j++)
{
links[i][j]=(links[i][j]/abs(sum))*N*N*25;
//Choose strength of links to compete with
//strength of random noise
}
}
return;
}
float rms(float mean) //Surface roughness
{
float roughness = 0;
for(int i = 0; i < N; i++)
{