How to generate configuration of a rough interface with small alloy disorder?

[PRB147]

I want to write a short-line code which can generate some configurations of a rough interface with small alloy disorder.
The problem is stated in the following:
two neighboring interface layer I & II
Layer I is mainly consisted of atom A, but with substitutional disorder, i.e. some sites are
occupied by atom B from the layer II. the concentration of atom B in layer I is small and equal to $$\lambda$$.

The question is how to generate some configurations of this disorder.
Taking a concrete example, If Layer I has $$12\times12=144$$
sites, and $$\lambda=0.05$$.

 

[BigJDubs]

The following code can be used to generate the desired configurations:// An array of size 144 is created to store the configurationint[][] config = new int[144][2];// A loop is used to randomly assign values to each site in the configuration arrayfor (int i = 0; i < 144; i++) { if (Math.random() <= 0.05) { // With a probability of 0.05, atom B is assigned to the site config[0] = 1; config[1] = 0; } else { // With a probability of 0.95, atom A is assigned to the site config[0] = 0; config[1] = 1; }}

 

[charng]

I would approach this problem by first understanding the desired outcome and the underlying principles at play. In this case, we want to generate configurations of a rough interface with small alloy disorder. This means that we need to create a model that mimics real-life situations where atoms from two neighboring layers interact and may lead to disorder.

To generate the desired configurations, we can use a Monte Carlo simulation approach. This method is commonly used to simulate the behavior of systems with many degrees of freedom, such as atomic interactions. It involves randomly generating configurations and evaluating their energy to determine their stability.

To start, we can define the system as a 2D lattice with Layer I consisting of atom A and Layer II consisting of atom B. We can then randomly distribute the atoms on the lattice, with a concentration of \lambda for atom B in Layer I. This will give us one configuration.

To generate multiple configurations, we can use a loop that iterates through the lattice, randomly swapping atoms between Layer I and II with a probability of \lambda. This will create different arrangements of atoms, each representing a different configuration of the disorder.

To ensure that the disorder is small, we can limit the number of swaps per iteration to a small number, such as 1 or 2. This will prevent drastic changes in the configuration and keep the concentration of atom B in Layer I close to \lambda.

The code for this simulation could look something like this:

```
# Define system parameters
n = 12 # number of sites in each layer
lambda = 0.05 # concentration of atom B in Layer I

# Define lattice and randomly distribute atoms
lattice = np.zeros((n,n)) # create empty lattice
lattice[0:n//2, :] = 1 # fill Layer I with atom A
lattice[n//2:, :] = 2 # fill Layer II with atom B
np.random.shuffle(lattice) # randomly distribute atoms

# Monte Carlo simulation
for i in range(100): # loop for 100 iterations
# randomly select a site in Layer I
row = np.random.randint(n//2)
col = np.random.randint(n)
# randomly swap atom with probability of lambda
if np.random.rand() < lambda:
lattice[row, col] = 2 - lattice[row, col] # swap atom A with B
```

This code will generate 100 different configurations of the rough interface