I hate this so much

Tital

Abstract

1Introduction
In this report, the construction of two cellular autonoma will be considered in the context of real-world systems that they attempt to model. In the course of the investigation, the autonima will be adjusted to attempt to model the systems under different conditions, and a quantative discussion of how the conditions affect the models will be made.


2Diffusion limited aggregation
DLA is a process in which particles wonder at random on some smooth surface (substrate) before bonding to some defect. Despite the random nature of the growth, it gives rise to characteristic, statistically similar growth patterns around the defect. Various statistical properties of the aggregates, (in this investigation we will concern ourselves mostly with its dimensionality) are dependant on properties of the system; in this investigation these relationships will be explored
In the course of this investigation, values corresponding to binding energy/free energy ratio, and the isotropy of the substrate will be considered. As well as this, various aspects of the model will be adjusted which have no clear physical equivalent, often to the end of proving that the choice of a unphysical option does not necessarily invalidate the results obtained.

In the real world, DLA occurs during the deposition of metals during electrochemical reactions

Algorithm
Basic

To start with, this model will consider the accumulation of partials around a single defect. The most basic Algorithm for producing DLA is outlined below:

1/ Create a blank grid with a single particle fixed in the centre.

2/ Produce a new particle at a radius rstart and a random direction from the initial particle, where rstart is slightly larger than the maximum radius of the aggregate.

3/ Move the new particle in a random direction on the grid by one grid square.

4/ Check if moving particle is adjacent to any fixed particles;
if it isn’t, go to 3
if it is, attach the particle and go to 2

The initial assumption is that this will produce a roughly spherical bundle of particles, however a little extra though or actual implementation will show that it produces something rather more complicated and interesting, as shown in Fig 1

Fig 1: an aggregate

Assumptions
This Algorithm has a couple of problems- it assumes that partials approach the aggregate evenly from all directions (which is reasonable if considering some systems, and less so when considering others.
It assumes that the moving particle never walks off the edge of the grid, despite the fact that the grid can not be infinite. A related assumption is made that there is enough time and computing power to follow the particle as it takes the most circuitous route possible to the aggregate.

Improvements

Thus, to improve the efficiency of the algorithm, it is normal to add another radius rkill at a significant distance from the aggregate, once the wandering particle passes rkill, it is assumed that it will not interact with the aggregate, and it is destroyed, a new wandering particle being added as in step 2/

The step described above essentially assumes that when a particle reaches the radius rkill, it is equally likely to re-approach the aggregate from any direction. If r kill was actually at infinity, this would be a reasonable assumption. When rkill is merely very large there is a possibility that this will in someway skew the growth of the aggregate away from the random direction that the particle left in.
It seams reasonable that over time, there will be as many particals leaving in any given direction, and his skewing will even out, but to keep the simulation as physical as possible, it is advantageous to set rkill as large as possible.

This, of course, rather defeats the object of rkill in the first place, but it does mean that the limitation is a known, controlled quantity.

Long steps
A further improvement is to realize that once the particle is a significant distance from the aggregate, the minute detail of its movement becomes irrelevant. For any moving particle, there is an even probability for it to reach any point on a circle centred on its current position. Thus it is possible to add another region between the aggregate and rkill in which the particle takes steps long enough to land it back in the normal movement region in a random direction.

Investigations
With the addition of a new subroutine to the code, it is possible to make reliable measurements of the dimentionality of the aggregate. This subroutine is outline below.

Declares that this is a routine to be called by the void command, taking no argmeunts
void dimension()
{
Declares that this routine will contain the variables I,x,y which are integers and Rn,particals_less_than_R, which are doubles ( a type of floating point decimal)
int i,x,y;
double Rn,particals_less_than_R;

counts Rn 10/50ths of the finished aggregates rmax to 40/50ths, in 50ths. This means that the outermost fringes of the aggregate, which are yet to become fully developed are not considered, and the innermost area of the aggregate where there is only a small number of particles to average over is not considered.
for(i=10;i<40;i++)
{Rn=i*rmax/50;
sets the number of particals so far counted to 0
particals_less_than_R=0;
scans through all the squares on the grid
for(x=0;x

( Error: Irreparable invalid markup in entry. Raw contents behind the cut. )

any better?

Tital

Abstract

1Introduction
In this report, the construction of two cellular autonoma will be considered in the context of real-world systems that they attempt to model. In the course of the investigation, the autonima will be adjusted to attempt to model the systems under different conditions, and a quantative discussion of how the conditions affect the models will be made.


2Diffusion limited aggregation
DLA is a process in which particles wonder at random on some smooth surface (substrate) before bonding to some defect. Despite the random nature of the growth, it gives rise to characteristic, statistically similar growth patterns around the defect. Various statistical properties of the aggregates, (in this investigation we will concern ourselves mostly with its dimensionality) are dependant on properties of the system; in this investigation these relationships will be explored
In the course of this investigation, values corresponding to binding energy/free energy ratio, and the isotropy of the substrate will be considered. As well as this, various aspects of the model will be adjusted which have no clear physical equivalent, often to the end of proving that the choice of a unphysical option does not necessarily invalidate the results obtained.

In the real world, DLA occurs during the deposition of metals during electrochemical reactions

Algorithm
Basic

To start with, this model will consider the accumulation of partials around a single defect. The most basic Algorithm for producing DLA is outlined below:

1/ Create a blank grid with a single particle fixed in the centre.

2/ Produce a new particle at a radius rstart and a random direction from the initial particle, where rstart is slightly larger than the maximum radius of the aggregate.

3/ Move the new particle in a random direction on the grid by one grid square.

4/ Check if moving particle is adjacent to any fixed particles;
if it isn’t, go to 3
if it is, attach the particle and go to 2

The initial assumption is that this will produce a roughly spherical bundle of particles, however a little extra though or actual implementation will show that it produces something rather more complicated and interesting, as shown in Fig 1

Fig 1: an aggregate

Assumptions
This Algorithm has a couple of problems- it assumes that partials approach the aggregate evenly from all directions (which is reasonable if considering some systems, and less so when considering others.
It assumes that the moving particle never walks off the edge of the grid, despite the fact that the grid can not be infinite. A related assumption is made that there is enough time and computing power to follow the particle as it takes the most circuitous route possible to the aggregate.

Improvements

Thus, to improve the efficiency of the algorithm, it is normal to add another radius rkill at a significant distance from the aggregate, once the wandering particle passes rkill, it is assumed that it will not interact with the aggregate, and it is destroyed, a new wandering particle being added as in step 2/

The step described above essentially assumes that when a particle reaches the radius rkill, it is equally likely to re-approach the aggregate from any direction. If r kill was actually at infinity, this would be a reasonable assumption. When rkill is merely very large there is a possibility that this will in someway skew the growth of the aggregate away from the random direction that the particle left in.
It seams reasonable that over time, there will be as many particals leaving in any given direction, and his skewing will even out, but to keep the simulation as physical as possible, it is advantageous to set rkill as large as possible.

This, of course, rather defeats the object of rkill in the first place, but it does mean that the limitation is a known, controlled quantity.

Long steps
A further improvement is to realize that once the particle is a significant distance from the aggregate, the minute detail of its movement becomes irrelevant. For any moving particle, there is an even probability for it to reach any point on a circle centred on its current position. Thus it is possible to add another region between the aggregate and rkill in which the particle takes steps long enough to land it back in the normal movement region in a random direction.

Investigations
With the addition of a new subroutine to the code, it is possible to make reliable measurements of the dimentionality of the aggregate. This subroutine is outline below.

Declares that this is a routine to be called by the void command, taking no argmeunts
void dimension()
{
Declares that this routine will contain the variables I,x,y which are integers and Rn,particals_less_than_R, which are doubles ( a type of floating point decimal)
int i,x,y;
double Rn,particals_less_than_R;

counts Rn 10/50ths of the finished aggregates rmax to 40/50ths, in 50ths. This means that the outermost fringes of the aggregate, which are yet to become fully developed are not considered, and the innermost area of the aggregate where there is only a small number of particles to average over is not considered.
for(i=10;i<40;i++)
{Rn=i*rmax/50;
sets the number of particals so far counted to 0
particals_less_than_R=0;
scans through all the squares on the grid
for(x=0;x

( Error: Irreparable invalid markup in entry. Raw contents behind the cut. )

(no subject)

1Introduction
In this report, the construction of two cellular autonoma will be considered in the context of real-world systems that they attempt to model. In the course of the investigation, the autonima will be adjusted to attempt to model the systems under different conditions, and a quantative discussion of how the conditions affect the models will be made.

(no subject)

2Diffusion limited aggregation
DLA is a process in which particles wonder at random on some smooth surface (substrate) before bonding to some defect. Despite the random nature of the growth, it gives rise to characteristic, statistically similar growth patterns around the defect. Various statistical properties of the aggregates, (in this investigation we will concern ourselves mostly with its dimensionality) are dependant on properties of the system; in this investigation these relationships will be explored
In the course of this investigation, values corresponding to binding energy/free energy ratio, and the isotropy of the substrate will be considered. As well as this, various aspects of the model will be adjusted which have no clear physical equivalent, often to the end of proving that the choice of a unphysical option does not necessarily invalidate the results obtained.

In the real world, DLA occurs during the deposition of metals during electrochemical reactions

(no subject)

Algorithm
Basic

To start with, this model will consider the accumulation of partials around a single defect. The most basic Algorithm for producing DLA is outlined below:

1/ Create a blank grid with a single particle fixed in the centre.

2/ Produce a new particle at a radius rstart and a random direction from the initial particle, where rstart is slightly larger than the maximum radius of the aggregate.

3/ Move the new particle in a random direction on the grid by one grid square.

4/ Check if moving particle is adjacent to any fixed particles;
if it isn’t, go to 3
if it is, attach the particle and go to 2

The initial assumption is that this will produce a roughly spherical bundle of particles, however a little extra though or actual implementation will show that it produces something rather more complicated and interesting, as shown in Fig 1

Fig 1: an aggregate

(no subject)

Assumptions
This Algorithm has a couple of problems- it assumes that partials approach the aggregate evenly from all directions (which is reasonable if considering some systems, and less so when considering others.
It assumes that the moving particle never walks off the edge of the grid, despite the fact that the grid can not be infinite. A related assumption is made that there is enough time and computing power to follow the particle as it takes the most circuitous route possible to the aggregate.

(no subject)

Improvements

Thus, to improve the efficiency of the algorithm, it is normal to add another radius rkill at a significant distance from the aggregate, once the wandering particle passes rkill, it is assumed that it will not interact with the aggregate, and it is destroyed, a new wandering particle being added as in step 2/

The step described above essentially assumes that when a particle reaches the radius rkill, it is equally likely to re-approach the aggregate from any direction. If r kill was actually at infinity, this would be a reasonable assumption. When rkill is merely very large there is a possibility that this will in someway skew the growth of the aggregate away from the random direction that the particle left in.
It seams reasonable that over time, there will be as many particals leaving in any given direction, and his skewing will even out, but to keep the simulation as physical as possible, it is advantageous to set rkill as large as possible.

This, of course, rather defeats the object of rkill in the first place, but it does mean that the limitation is a known, controlled quantity.

(no subject)

Long steps
A further improvement is to realize that once the particle is a significant distance from the aggregate, the minute detail of its movement becomes irrelevant. For any moving particle, there is an even probability for it to reach any point on a circle centred on its current position. Thus it is possible to add another region between the aggregate and rkill in which the particle takes steps long enough to land it back in the normal movement region in a random direction.

(no subject)

Investigations
With the addition of a new subroutine to the code, it is possible to make reliable measurements of the dimentionality of the aggregate. This subroutine is outline below.

Declares that this is a routine to be called by the void command, taking no argmeunts
void dimension()
{
Declares that this routine will contain the variables I,x,y which are integers and Rn,particals_less_than_R, which are doubles ( a type of floating point decimal)
int i,x,y;
double Rn,particals_less_than_R;

counts Rn 10/50ths of the finished aggregates rmax to 40/50ths, in 50ths. This means that the outermost fringes of the aggregate, which are yet to become fully developed are not considered, and the innermost area of the aggregate where there is only a small number of particles to average over is not considered.
for(i=10;i<40;i++)
{Rn=i*rmax/50;
sets the number of particals so far counted to 0
particals_less_than_R=0;
scans through all the squares on the grid
for(x=0;x<N;x++) {for(y=0;y<N;y++) checks if the currently considered square contains a particle {if (grid[x][y] != 0) checks if the currently considered square is within radius Rn {if ((x-N/2)*(x-N/2) + (y-N/2)*(y-N/2) < Rn*Rn) if both these checks are true, increments the value of particals_less_than_R particals_less_than_R++; } } } prints the number of particles within Rn and Rn to the output file fprintf(fp, "%f, %f \n", log(Rn),log(particals_less_than_R*1.0)); } }

(no subject)

The pairs of values that this produces (logs of the no of partical again can be plotted to give a graph, the gradient of the line gives the dimensionality of the aggregate.
Using the value of the dimensionality gives a quantaive value to the growth of the aggregate, which makes it possible to measure how changing certain factors affects the process. These factors and there effects will be discussed in the next section
Fig 2: the disadvantage of using the complete data set- note the curve at the high end of the line (from uncompleted aggregation) and the gaps between the trend line and the points at the bottom of the line (from inaccuracies possible only when averageing over a small sample)

(no subject)

Factors
Joining direction
The first factor considered was what constituted an ‘adjacent’ cell. Either the partical only attaches to occupied cells on the cardinal points, or it can attach to all 8 cells around it.

This is a relatively easy piece of coding to implement, requiring a new button, to change the value of join between 0 and 1, thus selecting one of the two joining styles, and the current detection code to be replaced with the section below:

If joining style =1
if (join ==1)
{
check if any of eight nearest neighbours are occupied, if so return “a”, the flag to attach the moving partical
if (grid[x+1+N/2][y+N/2]+
grid[x-1+N/2][y+N/2]+
grid[x+N/2][y+1+N/2]+
grid[x+N/2][y-1+N/2]+
grid[x+1+N/2][y+1+N/2]+
grid[x-1+N/2][y+1+N/2]+
grid[x-1+N/2][y-1+N/2]+
grid[x+1+N/2][y-1+N/2] >0)return 'a';
}

If joining style =10
if (join ==0)
check if any of the neighbours at cardinal points are occupied, if so return “a”, the flag to attach the moving particle
{
if(grid[x+1+N/2][y+N/2]+ /* check if square nearest neighbours occupied */
grid[x-1+N/2][y+N/2]+
grid[x+N/2][y+1+N/2]+
grid[x+N/2][y-1+N/2] >0)return 'a';
}

By setting the joining style to the two different possibilities, and running the programme, it is hoped that it will be possible to obtain characteristic dimension for the two different set ups, thus it should be possible to look at the density of two different aggregates and determine something of the algorithm that lead to them.
By loading the data produced by the program into excel it is possible to perform a full regression analysis on the data.
This not only gives the dimension of the aggregate, but gives a standard error, which is a measure of how accurately a trend line with a coefficient of the dimension would fit to the points.

(no subject)

(Square)Dimention std error (Diagonal)Diagonal std error
1.635717 0.011707 1.542486 0.023991
1.548211 0.03069 1.493954 0.01667
1.513041 0.011111 1.548114 0.023105
1.437263 0.036308 1.556609 0.021111
1.57793 0.026993 1.454859 0.024806
range 0.198454 0.093255

As is readily apparent, there is no significant difference between the range of dimensions of square-attaching particles and diagonal-attaching particles. Even more than that it is apparent that the standard error of each line does little to reflect the range of dimensions that can be produced by identical algorithms.

(no subject)

Joining probability
A change which can be made to perhaps greater effect, is to change the probability of the moving particle sticking. This is achieved by adding an extra check of a random number between 0 and 1 being less than prob, the probability of sticking before returning ‘a’, and a certain amount of extra book keeping to prvent the moving partical from eneering an occupied cell. As the data below and fig 1 shows,

Sticking probablity Dimention
1 1.542486 0.023991
1 1.493954 0.01667
1 1.548114 0.023105
1 1.556609 0.021111
1 1.454859 0.024806

0.1 1.487086 0.016227
0.1 1.517883 0.00667
0.1 1.639559 0.011123
0.1 1.631917 0.015794
0.1 1.558151 0.013197

It is to b expected that since a lower sticking probability allows wandering particles to work their way deeper into the aggregate, it is to be expected that a lower sticking probability will lead to a higher dimensioned aggregate.

(no subject)

Asymtopey

Qualative discussion
Multiple seeds

(no subject)

3Bak Sneppen Model of evolution
Once again this is a cellular autonima, designed to model the evolution of a group of species. The algorithm operates on a grid, each square of which represents a species. The fitness of the species to survive in its current environment is represented by a single number; there is nothing to distinguish between species which fulfil different roles.
To start with each species is assigned a (psudo) random number between 0 and 1 to represent its fitness for survival. From the point, the algorthem operates as follows

1/Select the least fit species (Assumption; species on the brink experience more deaths and hence more intense competition and more rapid evolution than those whose survival is assured)

2/ reassign its fitness randomly.

3/The neighbouring species are those that are have a relationship of some kind. As such the fitness of the neighbouring species is also reassigned at random.

4/ Repeat from 1

Although this model is rather crude and makes some huge assumptions and simplifications, it does produce a rather interesting distribution of fitnesses- no species have less than the critical fitness (which changes with the details of the system) and there is a roughly even distribution of fitnesses amoungst the species above this point. This is shown in fig [BS1]


Fig[BS1] distrubution of fitnesses in a Bak-Sneppen system

(no subject)

Finite size effects.
It is suggested that the shape of the fitness distribution could be affected by the size of the model being considered. This can be easily considered using the code provided. As these experiments were can it became clear that the larger the system, the sharper the cut-off. To determine a quantative value, the critical fitness was defined as being the point where the graph was at its steepest. As is shown in Fig BS2, the rere was little change to the position of th


A more sophisticated approach

In principle it would be possible to get a different measure of the critical fitness by averaging the number of species with a fitness between .5 and 1(which you are sure is beyond the step) and checking where the number of species of a given fitness changes from being less than half this value to more than half this value. This is illustrated in Fig [BS3]


Fig[BS3] A more sophisticated approach to calculating the critical fitness

Changing the meaning of ‘neighbouring’ species
It is possible to conceive of circumstances under which the definition of neighboring species would be different from that first modelled. The number of species that a given species interacts with is not always 4, and so I investigate d what happens if you adjust step 3 of the algorithm so that not only are the nearest neighbors affewcted, but all of those inside the Longer range interactions between species shown in Fig [BS4]


Fig[BS 4] range of interactions between cells in the autonima in this investigation


incease determined
4Summery
4Summery