AbstractGrowthLattice (Morphokinetics)

java.lang.Object
- kineticMonteCarlo.lattice.AbstractLattice
- - kineticMonteCarlo.lattice.AbstractGrowthLattice

All Implemented Interfaces:

IDevitaLattice

Direct Known Subclasses:

AgLattice, BasicGrowthLattice, CatalysisLattice, GrapheneLattice
```
public abstract class AbstractGrowthLattice
extends AbstractLattice
implements IDevitaLattice
```
In this case we assume that the unit cell is one and it only contains one element. Thus, we can maintain the previous logic, where there is no any unit cell at all.

Author:

N. Ferrando, J. Alberdi-Rodriguez

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`atomTypesAmount`
`private int[]`	`atomTypesCounter`
`private double`	`centreMassDistance`
`private int[]`	`emptyTypesCounter`
`private int`	`hexaArea`
`private long`	`hops`
`private java.util.ArrayList<java.lang.Integer>`	`includePerimeterList`
`private int`	`innerPerimeter`
`private int`	`islandCount`
`private java.util.ArrayList<Island>`	`islands`
`private int`	`mobileAtoms`
`private ModifiedBuffer`	`modified`
`private int`	`monomerCount`
`private int`	`multiAtomsIndex`
`private java.util.Map<java.lang.Integer,MultiAtom>`	`multiAtomsMap`
`private int`	`occupied`
`private int`	`outerPerimeter`
`private double`	`tracerDistance`
`private SimpleUc[][]`	`ucArray` Unit cell array, where all the atoms are located.
`static float`	`Y_RATIO`

Constructor Summary

Constructors
Constructor and Description

AbstractGrowthLattice(int hexaSizeI, int hexaSizeJ, ModifiedBuffer modified)

Constructors
Constructor and Description
`AbstractGrowthLattice(int hexaSizeI, int hexaSizeJ, ModifiedBuffer modified)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`(package private) void`	`addAtom(AbstractGrowthAtom atom)`
`(package private) void`	`addBondAtom(AbstractGrowthAtom atom)`
`private MultiAtom`	`addMultiAtomIsland(AbstractGrowthAtom atom, AbstractGrowthAtom neighbour, int i)`
`void`	`addOccupied()` Adds an occupied location to the counter.
`private boolean`	`allMultiAtomsDifferent(AbstractGrowthAtom atom, AbstractGrowthAtom neighbour)`
`abstract void`	`changeOccupationByHand(double xMouse, double yMouse, int scale)`
`private double`	`computeDiffusivity()`
`int`	`countIslands(java.io.PrintWriter print)` Counts the number of islands that the simulation has.
`void`	`countPerimeter(java.io.PrintWriter print)` Counts the sum of all islands perimeters.
`abstract void`	`deposit(AbstractGrowthAtom atom, boolean forceNucleation)`
`abstract double`	`extract(AbstractGrowthAtom atom)` Extract the given atom from the lattice.
`AbstractGrowthAtom`	`getAtom(int index)` Deprecated.
`AbstractGrowthAtom`	`getAtom(int iHexa, int jHexa)` Deprecated.
`AbstractGrowthAtom`	`getAtom(int iHexa, int jHexa, int unitCellPos)`
`AbstractAtom`	`getAtom(int iHexa, int jHexa, int kHexa, int unitCellPos)`
`java.lang.String`	`getAtomTypesCounter()`
`float`	`getAverageGyradius()` Computes the average distances to the centre of mass for all islands.
`abstract Point2D`	`getCartesianLocation(int iHexa, int jHexa)` Obtains the spatial location of certain atom, the distance between atoms is considered as 1 Returns the Cartesian position, given the hexagonal (lattice) location.
`abstract float`	`getCartSizeX()`
`abstract float`	`getCartSizeY()`
`abstract double`	`getCartX(int iHexa, int jHexa)`
`abstract double`	`getCartY(int jHexa)`
`abstract AbstractGrowthAtom`	`getCentralAtom()` Returns the atom that it is in the middle of single flake simulation.
`abstract Point2D`	`getCentralCartesianLocation()`
`void`	`getCentreOfMass()` Calculates the centre of mass of each island.
`double`	`getCmDistance()`
`float`	`getCoverage()`
`void`	`getDistancesToCentre()` Computes each atoms distance to the centre of mass.
`double`	`getDistanceToCenter(double x, double y)` Returns the distance of the given x,y point to the centre.
`double`	`getDistanceToCenter(int iHexa, int jHexa)`
`java.lang.String`	`getEmptyTypesCounter()`
`abstract int`	`getiHexa(double xCart, double yCart)` Knowing the X and Y Cartesian location, returns closest atom hexagonal coordinate.
`int`	`getInnerPerimeterLenght()` Inner perimeter is the sum of atoms that are occupied and have some neighbour not occupied.
`Island`	`getIsland(int i)`
`int`	`getIslandCount()` Only defined in growth lattice.
`java.util.Iterator<Island>`	`getIslandIterator()`
`abstract int`	`getjHexa(double yCart)` Knowing the X and Y Cartesian location, returns closest atom hexagonal coordinate.
`int`	`getMobileAtoms()` How many mobile atoms are.
`int`	`getMonomerCount()` Monomers are atoms without neighbours.
`MultiAtom`	`getMultiAtom(int i)`
`int`	`getMultiAtomCount()`
`java.util.Iterator<MultiAtom>`	`getMultiAtomIterator()`
`java.util.Iterator`	`getMultiAtomsIterator()`
`abstract AbstractGrowthAtom`	`getNeighbour(int iHexa, int jHexa, int neighbour)`
`int`	`getOccupied()`
`int`	`getOuterPerimeterLenght()` Outer perimeter is the sum of atoms that are not occupied and are touching an occupied one.
`long`	`getTotalHops()` How many steps has been moved all the atoms.
`double`	`getTracerDistance()` How far in average is an atom from where it was deposited.
`AbstractGrowthUc`	`getUc(int pos)`
`AbstractGrowthUc`	`getUc(int iLattice, int jLattice)`
`java.util.ArrayList<MultiAtom>`	`identifyAddMultiAtom(AbstractGrowthAtom atom)` Counts the number of islands from current atom.
`void`	`identifyIsland(AbstractGrowthAtom atom, boolean first, boolean fromNeighbour)` Counts the number of islands from current atom.
`private void`	`identifyIsland(AbstractGrowthAtom atom, boolean fromNeighbour, int xDiference, int yDiference)` Counts the number of islands that the simulation has.
`double`	`identifyRemoveMultiAtomIsland(AbstractGrowthAtom atom)`
`void`	`initialiseRates(double[][] probabilities)` Default rates to jump from one type to the other.
`private boolean`	`onlyOneNeighbourInCommon(AbstractGrowthAtom atom, AbstractGrowthAtom neighbour)` Edge diffusion can only happen when two atoms are in an edge.
`void`	`printDistances()`
`private double`	`removeMultiAtom(AbstractGrowthAtom atom)`
`void`	`reset()`
`void`	`resetOccupied()` Resets to zero the number of occupied locations.
`(package private) void`	`setAngles()`
`void`	`setAtoms(AbstractGrowthAtom[][] atoms)`
`void`	`setAtomsTypesCounter(int length)`
`java.util.List<AbstractGrowthAtom>`	`setInsideCircle(int radius, boolean periodicSingleFlake)` Defines which atoms are inside from the current position (centre) and given radius.
`java.util.List<AbstractGrowthAtom>`	`setInsideSquare(int radius)` Defines which atoms are inside from the current position.
`int`	`size()`
`void`	`subtractOccupied()` Subtracts an occupied location from the counter.
`void`	`swapAtomsInMultiAtom(AbstractGrowthAtom origin, AbstractGrowthAtom destination)`
`void`	`swapIsland(Island origin, Island destination)`
`private double`	`toZeroIfTooClose(double value)`

Methods inherited from class kineticMonteCarlo.lattice.AbstractLattice
getHexaSizeI, getHexaSizeJ, getHexaSizeK, getUnitCellSize, isPaused, setHexaSizeI, setHexaSizeJ, setHexaSizeK, setPaused, setProbabilities, setUnitCellSize

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface kineticMonteCarlo.lattice.IDevitaLattice
getAvailableDistance, getFarSite

- Field Detail
  - Y_RATIO
```
public static final float Y_RATIO
```
  - ucArray
```
private final SimpleUc[][] ucArray
```
    Unit cell array, where all the atoms are located.
  - modified
```
private final ModifiedBuffer modified
```
  - includePerimeterList
```
private final java.util.ArrayList<java.lang.Integer> includePerimeterList
```
  - hexaArea
```
private final int hexaArea
```
  - occupied
```
private int occupied
```
  - islandCount
```
private int islandCount
```
  - multiAtomsIndex
```
private int multiAtomsIndex
```
  - monomerCount
```
private int monomerCount
```
  - atomTypesCounter
```
private int[] atomTypesCounter
```
  - emptyTypesCounter
```
private int[] emptyTypesCounter
```
  - atomTypesAmount
```
private int atomTypesAmount
```
  - islands
```
private java.util.ArrayList<Island> islands
```
  - multiAtomsMap
```
private final java.util.Map<java.lang.Integer,MultiAtom> multiAtomsMap
```
  - innerPerimeter
```
private int innerPerimeter
```
  - outerPerimeter
```
private int outerPerimeter
```
  - tracerDistance
```
private double tracerDistance
```
  - centreMassDistance
```
private double centreMassDistance
```
  - mobileAtoms
```
private int mobileAtoms
```
  - hops
```
private long hops
```
- Constructor Detail
  - AbstractGrowthLattice
```
public AbstractGrowthLattice(int hexaSizeI,
                             int hexaSizeJ,
                             ModifiedBuffer modified)
```
- Method Detail
  - getNeighbour
```
public abstract AbstractGrowthAtom getNeighbour(int iHexa,
                                                int jHexa,
                                                int neighbour)
```
  - getCartesianLocation
```
public abstract Point2D getCartesianLocation(int iHexa,
                                             int jHexa)
```
    Obtains the spatial location of certain atom, the distance between atoms is considered as 1 Returns the Cartesian position, given the hexagonal (lattice) location.
    
    Parameters:
    
    iHexa - i index in the hexagonal mesh.
    
    jHexa - j index in the hexagonal mesh.
    
    Returns:
    
    spatial location in Cartesian.
  - getCentralCartesianLocation
```
public abstract Point2D getCentralCartesianLocation()
```
  - getCartSizeX
```
public abstract float getCartSizeX()
```
  - getCartSizeY
```
public abstract float getCartSizeY()
```
  - getCartX
```
public abstract double getCartX(int iHexa,
                                int jHexa)
```
  - getCartY
```
public abstract double getCartY(int jHexa)
```
  - getiHexa
```
public abstract int getiHexa(double xCart,
                             double yCart)
```
    Knowing the X and Y Cartesian location, returns closest atom hexagonal coordinate.
    
    Parameters:
    
    xCart - Cartesian X coordinate.
    
    yCart - Cartesian Y coordinate.
    
    Returns:
    
    i hexagonal position.
  - getjHexa
```
public abstract int getjHexa(double yCart)
```
    Knowing the X and Y Cartesian location, returns closest atom hexagonal coordinate.
    
    Parameters:
    
    yCart - Cartesian Y coordinate.
    
    Returns:
    
    j hexagonal position.
  - getAtom
```
@Deprecated
public AbstractGrowthAtom getAtom(int index)
```
    Deprecated.
    
    Return the selected atom.
    
    Parameters:
    
    index -
    
    Returns:
    
    selected atom.
  - getAtom
```
@Deprecated
public AbstractGrowthAtom getAtom(int iHexa,
                                              int jHexa)
```
    Deprecated.
    
    We ignore the unitCellPos by now, we get directly the atom of i,j hexagonal location.
    
    Parameters:
    
    iHexa -
    
    jHexa -
    
    Returns:
    
    required atom.
  - getAtom
```
public AbstractGrowthAtom getAtom(int iHexa,
                                  int jHexa,
                                  int unitCellPos)
```
  - getCentralAtom
```
public abstract AbstractGrowthAtom getCentralAtom()
```
    Returns the atom that it is in the middle of single flake simulation.
    
    Returns:
    
    central atom.
  - getUc
```
public AbstractGrowthUc getUc(int pos)
```
    Specified by:
    
    getUc in class AbstractLattice
  - getAtom
```
public AbstractAtom getAtom(int iHexa,
                            int jHexa,
                            int kHexa,
                            int unitCellPos)
```
    Specified by:
    
    getAtom in class AbstractLattice
  - setAtoms
```
public final void setAtoms(AbstractGrowthAtom[][] atoms)
```
  - setAngles
```
final void setAngles()
```
  - getInnerPerimeterLenght
```
public int getInnerPerimeterLenght()
```
    Inner perimeter is the sum of atoms that are occupied and have some neighbour not occupied. Thus, are in the limit of the island.
    
    Returns:
    
    number of atoms that are in the inner perimeter.
  - getOuterPerimeterLenght
```
public int getOuterPerimeterLenght()
```
    Outer perimeter is the sum of atoms that are not occupied and are touching an occupied one.
    
    Returns:
    
    number of atoms that are in the outer perimeter.
  - addOccupied
```
public void addOccupied()
```
    Adds an occupied location to the counter.
  - subtractOccupied
```
public void subtractOccupied()
```
    Subtracts an occupied location from the counter.
  - resetOccupied
```
public void resetOccupied()
```
    Resets to zero the number of occupied locations.
  - getCoverage
```
public float getCoverage()
```
    Returns:
    
    the coverage of the lattice.
  - getOccupied
```
public int getOccupied()
```
    Returns:
    
    number of occupied positions.
  - getUc
```
public AbstractGrowthUc getUc(int iLattice,
                              int jLattice)
```
  - getIsland
```
public Island getIsland(int i)
```
  - swapIsland
```
public void swapIsland(Island origin,
                       Island destination)
```
  - getMultiAtom
```
public MultiAtom getMultiAtom(int i)
```
  - getMultiAtomsIterator
```
public java.util.Iterator getMultiAtomsIterator()
```
  - getAverageGyradius
```
public float getAverageGyradius()
```
    Computes the average distances to the centre of mass for all islands.
    
    Specified by:
    
    getAverageGyradius in class AbstractLattice
    
    Returns:
    
    average gyradius.
  - getIslandCount
```
public int getIslandCount()
```
    Description copied from class: AbstractLattice
    
    Only defined in growth lattice.
    
    Specified by:
    
    getIslandCount in class AbstractLattice
    
    Returns:
    
    number of island of simulation (or -1)
  - getIslandIterator
```
public java.util.Iterator<Island> getIslandIterator()
```
  - getMultiAtomIterator
```
public java.util.Iterator<MultiAtom> getMultiAtomIterator()
```
  - getMultiAtomCount
```
public int getMultiAtomCount()
```
  - size
```
public int size()
```
    Overrides:
    
    size in class AbstractLattice
  - changeOccupationByHand
```
public abstract void changeOccupationByHand(double xMouse,
                                            double yMouse,
                                            int scale)
```
  - deposit
```
public abstract void deposit(AbstractGrowthAtom atom,
                             boolean forceNucleation)
```
  - extract
```
public abstract double extract(AbstractGrowthAtom atom)
```
    Extract the given atom from the lattice.
    
    Parameters:
    
    atom - the atom to be extracted.
    
    Returns:
    
    probability change (positive value).
  - getDistanceToCenter
```
public double getDistanceToCenter(int iHexa,
                                  int jHexa)
```
  - getDistancesToCentre
```
public void getDistancesToCentre()
```
    Computes each atoms distance to the centre of mass.
  - getDistanceToCenter
```
public double getDistanceToCenter(double x,
                                  double y)
```
    Returns the distance of the given x,y point to the centre.
    
    Parameters:
    
    x - Cartesian coordinate.
    
    y - Cartesian coordinate.
    
    Returns:
    
    distance.
  - getMonomerCount
```
public int getMonomerCount()
```
    Monomers are atoms without neighbours. After have counted them with countIslands(java.io.PrintWriter), the number of monomers is available.
    
    Returns:
    
    number of monomers.
  - getCentreOfMass
```
public void getCentreOfMass()
```
    Calculates the centre of mass of each island. The result is stored in "centres" vector. The way to compute the distances is considering periodic boundary conditions and the algorithm is taken from Wikipedia (https://en.wikipedia.org/wiki/Center_of_mass#Systems_with_periodic_boundary_conditions).
  - setAtomsTypesCounter
```
public void setAtomsTypesCounter(int length)
```
  - getAtomTypesCounter
```
public java.lang.String getAtomTypesCounter()
```
  - getEmptyTypesCounter
```
public java.lang.String getEmptyTypesCounter()
```
  - getTracerDistance
```
public double getTracerDistance()
```
    How far in average is an atom from where it was deposited. It is calculated in countIslands(java.io.PrintWriter) method.
    
    Returns:
    
    distance^2
  - getCmDistance
```
public double getCmDistance()
```
  - getTotalHops
```
public long getTotalHops()
```
    How many steps has been moved all the atoms. In practice, it should be the same number as the total rate - depositions.
    
    Returns:
  - getMobileAtoms
```
public int getMobileAtoms()
```
    How many mobile atoms are. It is calculated in countIslands(java.io.PrintWriter) method.
    
    Returns:
    
    atoms that are not bulk (island).
  - initialiseRates
```
public void initialiseRates(double[][] probabilities)
```
    Default rates to jump from one type to the other. For example, this matrix stores the rates to jump from terrace to edge.
    
    Parameters:
    
    probabilities - Default rates.
  - reset
```
public void reset()
```
    Specified by:
    
    reset in class AbstractLattice
  - setInsideCircle
```
public java.util.List<AbstractGrowthAtom> setInsideCircle(int radius,
                                                          boolean periodicSingleFlake)
```
    Defines which atoms are inside from the current position (centre) and given radius. Define como átomos inside a los átomos dentro de dicho rádio Devuelve un array de átomos que es el perimetro de dicha circunferencia.
    
    Parameters:
    
    radius -
    
    Returns:
    
    An array with the atoms that are in the circumference (only the perimeter).
  - setInsideSquare
```
public java.util.List<AbstractGrowthAtom> setInsideSquare(int radius)
```
    Defines which atoms are inside from the current position.
    
    Parameters:
    
    radius - is the half of the square side.
    
    Returns:
    
    An array with the atoms that are in the perimeter.
  - addAtom
```
void addAtom(AbstractGrowthAtom atom)
```
  - addBondAtom
```
void addBondAtom(AbstractGrowthAtom atom)
```
  - countIslands
```
public int countIslands(java.io.PrintWriter print)
```
    Counts the number of islands that the simulation has.
    
    Parameters:
    
    print - to where should print the output: null (nowhere), standard output or a file.
    
    Returns:
    
    number of islands.
  - countPerimeter
```
public void countPerimeter(java.io.PrintWriter print)
```
    Counts the sum of all islands perimeters. Results are saved in private attributes; call to getInnerPerimeterLenght() and getOuterPerimeterLenght() to get them.
    
    Parameters:
    
    print - to where should print the output: null (nowhere), standard output or a file.
  - printDistances
```
public void printDistances()
```
  - toZeroIfTooClose
```
private double toZeroIfTooClose(double value)
```
  - computeDiffusivity
```
private double computeDiffusivity()
```
  - identifyIsland
```
private void identifyIsland(AbstractGrowthAtom atom,
                            boolean fromNeighbour,
                            int xDiference,
                            int yDiference)
```
    Counts the number of islands that the simulation has. It iterates trough all neighbours, to set all them the same island number.
    
    Parameters:
    
    atom - atom to be classified.
    
    fromNeighbour - whether is called from outside or recursively.
  - identifyIsland
```
public void identifyIsland(AbstractGrowthAtom atom,
                           boolean first,
                           boolean fromNeighbour)
```
    Counts the number of islands from current atom. It iterates trough all neighbours, to set all them the same island number.
    
    Parameters:
    
    atom - atom to be classified.
    
    first - previously has detected that a neighbour atom is in an island.
    
    fromNeighbour - whether is called from outside or recursively.
  - swapAtomsInMultiAtom
```
public void swapAtomsInMultiAtom(AbstractGrowthAtom origin,
                                 AbstractGrowthAtom destination)
```
  - identifyAddMultiAtom
```
public java.util.ArrayList<MultiAtom> identifyAddMultiAtom(AbstractGrowthAtom atom)
```
    Counts the number of islands from current atom. It iterates trough all neighbours, to set all them the same island number.
    
    Parameters:
    
    atom - Atom to be classified.
    
    Returns:
    
    Created Island, null otherwise.
  - addMultiAtomIsland
```
private MultiAtom addMultiAtomIsland(AbstractGrowthAtom atom,
                                     AbstractGrowthAtom neighbour,
                                     int i)
```
  - allMultiAtomsDifferent
```
private boolean allMultiAtomsDifferent(AbstractGrowthAtom atom,
                                       AbstractGrowthAtom neighbour)
```
  - onlyOneNeighbourInCommon
```
private boolean onlyOneNeighbourInCommon(AbstractGrowthAtom atom,
                                         AbstractGrowthAtom neighbour)
```
    Edge diffusion can only happen when two atoms are in an edge. This can be identified by counting common neighbours: if only one neighbour is in common, true edge diffusion; if there are two, is not possible edge diffusion.
    
    Parameters:
    
    atom -
    
    neighbour -
    
    Returns:
  - identifyRemoveMultiAtomIsland
```
public double identifyRemoveMultiAtomIsland(AbstractGrowthAtom atom)
```
  - removeMultiAtom
```
private double removeMultiAtom(AbstractGrowthAtom atom)
```

Class AbstractGrowthLattice

Field Summary

Constructor Summary

Method Summary

Methods inherited from class kineticMonteCarlo.lattice.AbstractLattice

Methods inherited from class java.lang.Object

Methods inherited from interface kineticMonteCarlo.lattice.IDevitaLattice

Field Detail

Y_RATIO

ucArray

modified

includePerimeterList

hexaArea

occupied

islandCount

multiAtomsIndex

monomerCount

atomTypesCounter

emptyTypesCounter

atomTypesAmount

islands

multiAtomsMap

innerPerimeter

outerPerimeter

tracerDistance

centreMassDistance

mobileAtoms

hops

Constructor Detail

AbstractGrowthLattice

Method Detail

getNeighbour

getCartesianLocation

getCentralCartesianLocation

getCartSizeX

getCartSizeY

getCartX

getCartY

getiHexa

getjHexa

getAtom

getAtom

getAtom

getCentralAtom

getUc

getAtom

setAtoms

setAngles

getInnerPerimeterLenght

getOuterPerimeterLenght

addOccupied

subtractOccupied

resetOccupied

getCoverage

getOccupied

getUc

getIsland

swapIsland

getMultiAtom

getMultiAtomsIterator

getAverageGyradius

getIslandCount

getIslandIterator

getMultiAtomIterator

getMultiAtomCount

size

changeOccupationByHand

deposit

extract

getDistanceToCenter

getDistancesToCentre

getDistanceToCenter

getMonomerCount

getCentreOfMass

setAtomsTypesCounter

getAtomTypesCounter

getEmptyTypesCounter

getTracerDistance

getCmDistance

getTotalHops