AbstractGrowthAtom (Morphokinetics)

java.lang.Object
- kineticMonteCarlo.atom.AbstractAtom
- - kineticMonteCarlo.atom.AbstractGrowthAtom

All Implemented Interfaces:

java.lang.Comparable, IAtom, IElement

Direct Known Subclasses:

AgAtom, BasicGrowthAtom, CatalysisAtom, GrapheneAtom
```
public abstract class AbstractGrowthAtom
extends AbstractAtom
implements java.lang.Comparable, IElement
```
Author:

N. Ferrando, J. Alberdi-Rodriguez

Field Summary

Fields
Modifier and Type	Field and Description
`private double`	`angle`
`private AbstractGrowthAtomAttributes`	`attributes`
`private double[]`	`bondsProbability` Current probabilities to jump to neighbour position.
`private Point3D`	`cartesianPosition`
`private Point3D`	`cartesianSuperCell`
`private int`	`id` Unique identifier.
`private short`	`iHexa` Hexagonal i coordinate.
`private boolean`	`innerPerimeter`
`private short`	`jHexa` Hexagonal j coordinate.
`private int`	`multiplier`
`private int`	`occupiedNeighbours`
`private boolean`	`outerPerimeter`
`private boolean`	`outside`
`private double[][]`	`probabilities` Default rates to jump from one type to the other.
`private double`	`probability` Should be the sum of neighbour probabilities.
`private AbstractProcess[]`	`processes` Different processes that atom can do.
`private byte`	`type` Type of the atom.
`private boolean`	`visited` Helper attribute used when counting islands, to check if current atom has been already visited.

Fields inherited from class kineticMonteCarlo.atom.AbstractAtom
ARMCHAIR_EDGE, BULK, CORNER, EDGE, KINK, SICK, TERRACE, ZIGZAG_EDGE, ZIGZAG_WITH_EXTRA

Constructor Summary

Constructors
Constructor and Description
`AbstractGrowthAtom(int id, int numberOfNeighbours)` Dummy constructor to be able to have a proper AgAtom(pos) constructor.
`AbstractGrowthAtom(int id, short iHexa, short jHexa, int numberOfNeighbours, int numberOfProcesses)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addOccupiedNeighbour(int value)` An occupied atom is added to current neighbourhood (for the addition, can be a negative number).
`void`	`addProbability(double probability)`
`void`	`addRate(byte process, double rate, int neighbourPos)`
`void`	`addToSumRate(byte process, double rate)`
`abstract boolean`	`areTwoTerracesTogether()`
`boolean`	`areTwoTerracesTogetherInPerimeter(AbstractGrowthAtom originAtom)` It has one neighbour.
`abstract AbstractGrowthAtom`	`chooseRandomHop()`
`void`	`clear()` Resets current atom; TERRACE type, no neighbours, no occupied, no outside and no probability.
`int`	`compareTo(java.lang.Object o)` Compares IDs of two atoms.
`void`	`equalRate(byte process)`
`boolean`	`equals(java.lang.Object obj)` In general two atoms are equal if the have the same Id.
`abstract java.util.List`	`getAllNeighbours()`
`double`	`getAngle()`
`AbstractGrowthAtomAttributes`	`getAttributes()`
`double[]`	`getBondsProbability()`
`double`	`getBondsProbability(int i)` Get probability in the given neighbour position.
`Point3D`	`getCartesianPosition()`
`Point3D`	`getCartesianSuperCell()`
`Point3D`	`getDepositionPosition()`
`double`	`getDepositionTime()`
`double`	`getEdgeRate(byte process, int neighbourPos)`
`int`	`getHops()`
`int`	`getId()`
`short`	`getiHexa()`
`int`	`getIslandNumber()`
`short`	`getjHexa()`
`java.util.Set`	`getMultiAtomNumber()`
`int`	`getMultiplier()`
`abstract AbstractGrowthAtom`	`getNeighbour(int pos)`
`int`	`getOccupiedNeighbours()` How many neighbours are occupied.
`abstract int`	`getOrientation()`
`double`	`getProbability()`
`double`	`getProbability(int pos)`
`double`	`getProbability(int originType, int targetType)` Returns the predefined probability (from rates) to jump from origin type to target type.
`double`	`getRate(byte process)`
`double`	`getSumRate(byte process)`
`byte`	`getType()`
`abstract byte`	`getTypeWithoutNeighbour(int posNeighbour)` Returns the type of the neighbour atom if current one would not exist.
`int`	`hashCode()` Every atom will have an unique Id.
`void`	`initialiseRates(double[][] probabilities)` Default rates to jump from one type to the other.
`boolean`	`isInnerPerimeter()`
`boolean`	`isIsolated()` Checks if the current atom has occupied neighbours.
`boolean`	`isOnList(byte process)`
`boolean`	`isOuterPerimeter()`
`boolean`	`isOutside()`
`abstract boolean`	`isPartOfImmobilSubstrate()`
`boolean`	`isVisited()` When counting islands, we have to keep track of the visited atoms.
`abstract void`	`obtainRateFromNeighbours()`
`abstract double`	`probJumpToNeighbour(int originType, int position)`
`double`	`remove()`
`void`	`removeMultiAtomNumber(int multiAtomNumber)`
`void`	`removeMultiAtoms()` Removes all multi atoms that current atoms belonged to.
`void`	`resetPerimeter()`
`void`	`resetProbability()`
`void`	`setAngle(double angle)`
`void`	`setAttributes(AbstractGrowthAtomAttributes attributes)`
`void`	`setBondsProbability(double[] bondsProbability)`
`void`	`setBondsProbability(double value, int i)` Set the given probability in the given neighbour position.
`void`	`setCartesianPosition(Point3D cartesianPosition)`
`void`	`setCartesianSuperCell(Point3D cartesianSuperCell)`
`void`	`setDepositionPosition(Point3D position)`
`void`	`setDepositionTime(double time)` Stores when the atom has been deposited.
`void`	`setHops(int hops)`
`void`	`setInnerPerimeter()`
`void`	`setIslandNumber(int islandNumber)`
`void`	`setMultiAtomNumber(int multiAtomNumber)`
`void`	`setMultiplier(int multiplier)`
`abstract void`	`setNeighbour(AbstractGrowthAtom a, int pos)`
`void`	`setOnList(byte process, boolean onList)`
`void`	`setOuterPerimeter()`
`void`	`setOutside(boolean outside)`
`void`	`setProcceses(AbstractProcess[] processes)`
`void`	`setRate(byte process, double rate)`
`void`	`setSumRate(byte process, double rate)`
`void`	`setType(byte type)`
`void`	`setVisited(boolean visited)` When counting islands, we have to keep track of the visited atoms.
`void`	`swapAttributes(AbstractGrowthAtom atom)`
`java.lang.String`	`toString()`
`abstract double`	`updateOneBound(int bond)`
`double`	`updateRate()` If current atom is not eligible (thus, is immobile) return its probability in negative.

Methods inherited from class kineticMonteCarlo.atom.AbstractAtom
getNumberOfNeighbours, getPos, getProbabilities, getRealType, isOccupied, isOnList, isRemoved, setList, setNeighbour, setNumberOfNeighbours, setOccupied, setProbabilities, setRemoved, unRemove

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

Methods inherited from interface kineticMonteCarlo.atom.IAtom
isEligible

- Field Detail
  - type
```
private byte type
```
    Type of the atom. Some examples are; TERRACE, EDGE, KINK, ISLAND... Precise types are defined in child classes.
  - probabilities
```
private 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.
  - probability
```
private double probability
```
    Should be the sum of neighbour probabilities.
  - bondsProbability
```
private double[] bondsProbability
```
    Current probabilities to jump to neighbour position.
  - angle
```
private double angle
```
  - outside
```
private boolean outside
```
  - iHexa
```
private final short iHexa
```
    Hexagonal i coordinate.
  - jHexa
```
private final short jHexa
```
    Hexagonal j coordinate.
  - multiplier
```
private int multiplier
```
  - visited
```
private boolean visited
```
    Helper attribute used when counting islands, to check if current atom has been already visited.
  - id
```
private final int id
```
    Unique identifier.
  - innerPerimeter
```
private boolean innerPerimeter
```
  - outerPerimeter
```
private boolean outerPerimeter
```
  - cartesianPosition
```
private Point3D cartesianPosition
```
  - cartesianSuperCell
```
private Point3D cartesianSuperCell
```
  - attributes
```
private AbstractGrowthAtomAttributes attributes
```
  - occupiedNeighbours
```
private int occupiedNeighbours
```
  - processes
```
private AbstractProcess[] processes
```
    Different processes that atom can do. In catalysis: adsorption, desorption, reaction and diffusion.
- Constructor Detail
  - AbstractGrowthAtom
```
public AbstractGrowthAtom(int id,
                          short iHexa,
                          short jHexa,
                          int numberOfNeighbours,
                          int numberOfProcesses)
```
  - AbstractGrowthAtom
```
public AbstractGrowthAtom(int id,
                          int numberOfNeighbours)
```
    Dummy constructor to be able to have a proper AgAtom(pos) constructor.
    
    Parameters:
    
    id - atom identifier.
    
    numberOfNeighbours - number of neighbours that each atom has.
- Method Detail
  - getAttributes
```
public AbstractGrowthAtomAttributes getAttributes()
```
  - setAttributes
```
public void setAttributes(AbstractGrowthAtomAttributes attributes)
```
  - getId
```
public int getId()
```
  - getiHexa
```
public short getiHexa()
```
    Returns:
    
    hexagonal i coordinate
  - getjHexa
```
public short getjHexa()
```
    Returns:
    
    hexagonal j coordinate
  - getCartesianPosition
```
public Point3D getCartesianPosition()
```
  - setCartesianPosition
```
public void setCartesianPosition(Point3D cartesianPosition)
```
  - getCartesianSuperCell
```
public Point3D getCartesianSuperCell()
```
  - setCartesianSuperCell
```
public void setCartesianSuperCell(Point3D cartesianSuperCell)
```
  - getAngle
```
public double getAngle()
```
  - setAngle
```
public void setAngle(double angle)
```
  - isOutside
```
public boolean isOutside()
```
  - setOutside
```
public void setOutside(boolean outside)
```
  - getType
```
public byte getType()
```
    Specified by:
    
    getType in interface IAtom
  - setType
```
public void setType(byte type)
```
  - setMultiplier
```
public void setMultiplier(int multiplier)
```
  - getMultiplier
```
public int getMultiplier()
```
  - getBondsProbability
```
public double[] getBondsProbability()
```
    Returns:
    
    the bondsProbability.
  - getBondsProbability
```
public double getBondsProbability(int i)
```
    Get probability in the given neighbour position.
    
    Parameters:
    
    i - neighbour position.
    
    Returns:
    
    probability (rate).
  - setBondsProbability
```
public void setBondsProbability(double[] bondsProbability)
```
    Parameters:
    
    bondsProbability - the bondsProbability to set.
  - setBondsProbability
```
public void setBondsProbability(double value,
                                int i)
```
    Set the given probability in the given neighbour position.
    
    Parameters:
    
    value - probability (rate).
    
    i - neighbour position.
  - getProbability
```
public double getProbability()
```
    Specified by:
    
    getProbability in interface IAtom
  - resetProbability
```
public void resetProbability()
```
  - addProbability
```
public void addProbability(double probability)
```
  - getProbability
```
public double getProbability(int originType,
                             int targetType)
```
    Returns the predefined probability (from rates) to jump from origin type to target type.
    
    Parameters:
    
    originType - origin type, from where the atom is going to jump.
    
    targetType - target type, to where the atom is going to jump.
    
    Returns:
    
    the probabilities.
  - getProbability
```
public double getProbability(int pos)
```
  - setDepositionTime
```
public void setDepositionTime(double time)
```
    Stores when the atom has been deposited. It is defined first when an atom is deposited and it has to be moved with the corresponding diffusion.
    
    Parameters:
    
    time - deposition time or former time.
  - getDepositionTime
```
public double getDepositionTime()
```
    Returns:
    
    when the atom has been deposited.
  - setDepositionPosition
```
public void setDepositionPosition(Point3D position)
```
  - getDepositionPosition
```
public Point3D getDepositionPosition()
```
  - setHops
```
public void setHops(int hops)
```
  - getHops
```
public int getHops()
```
  - setIslandNumber
```
public void setIslandNumber(int islandNumber)
```
  - getIslandNumber
```
public int getIslandNumber()
```
  - setMultiAtomNumber
```
public void setMultiAtomNumber(int multiAtomNumber)
```
  - removeMultiAtomNumber
```
public void removeMultiAtomNumber(int multiAtomNumber)
```
  - removeMultiAtoms
```
public void removeMultiAtoms()
```
    Removes all multi atoms that current atoms belonged to.
  - getMultiAtomNumber
```
public java.util.Set getMultiAtomNumber()
```
  - isVisited
```
public boolean isVisited()
```
    When counting islands, we have to keep track of the visited atoms.
    
    Returns:
    
    whether current atoms has been previously visited.
  - setVisited
```
public void setVisited(boolean visited)
```
    When counting islands, we have to keep track of the visited atoms.
    
    Parameters:
    
    visited - whether current atoms is visited.
  - isIsolated
```
public boolean isIsolated()
```
    Checks if the current atom has occupied neighbours.
    
    Returns:
    
    true if the current atoms has no any occupied neighbour, false otherwise.
  - setInnerPerimeter
```
public void setInnerPerimeter()
```
  - setOuterPerimeter
```
public void setOuterPerimeter()
```
  - isInnerPerimeter
```
public boolean isInnerPerimeter()
```
  - isOuterPerimeter
```
public boolean isOuterPerimeter()
```
  - resetPerimeter
```
public void resetPerimeter()
```
  - getOccupiedNeighbours
```
public int getOccupiedNeighbours()
```
    How many neighbours are occupied.
    
    Returns:
    
    occupied neighbours.
  - addOccupiedNeighbour
```
public void addOccupiedNeighbour(int value)
```
    An occupied atom is added to current neighbourhood (for the addition, can be a negative number).
    
    Parameters:
    
    value - to be added or removed.
  - setProcceses
```
public final void setProcceses(AbstractProcess[] processes)
```
  - isOnList
```
public boolean isOnList(byte process)
```
  - setOnList
```
public void setOnList(byte process,
                      boolean onList)
```
    Specified by:
    
    setOnList in interface IElement
  - getRate
```
public double getRate(byte process)
```
    Specified by:
    
    getRate in interface IElement
  - getEdgeRate
```
public double getEdgeRate(byte process,
                          int neighbourPos)
```
  - setRate
```
public void setRate(byte process,
                    double rate)
```
    Specified by:
    
    setRate in interface IElement
  - addRate
```
public void addRate(byte process,
                    double rate,
                    int neighbourPos)
```
    Specified by:
    
    addRate in interface IElement
  - getSumRate
```
public double getSumRate(byte process)
```
    Specified by:
    
    getSumRate in interface IElement
  - setSumRate
```
public void setSumRate(byte process,
                       double rate)
```
    Specified by:
    
    setSumRate in interface IElement
  - addToSumRate
```
public void addToSumRate(byte process,
                         double rate)
```
    Specified by:
    
    addToSumRate in interface IElement
  - equalRate
```
public void equalRate(byte process)
```
    Specified by:
    
    equalRate in interface IElement
  - getTypeWithoutNeighbour
```
public abstract byte getTypeWithoutNeighbour(int posNeighbour)
```
    Returns the type of the neighbour atom if current one would not exist.
    
    Parameters:
    
    posNeighbour - current atom.
    
    Returns:
    
    the type.
  - areTwoTerracesTogether
```
public abstract boolean areTwoTerracesTogether()
```
  - chooseRandomHop
```
public abstract AbstractGrowthAtom chooseRandomHop()
```
  - getOrientation
```
public abstract int getOrientation()
```
  - obtainRateFromNeighbours
```
public abstract void obtainRateFromNeighbours()
```
  - probJumpToNeighbour
```
public abstract double probJumpToNeighbour(int originType,
                                           int position)
```
  - setNeighbour
```
public abstract void setNeighbour(AbstractGrowthAtom a,
                                  int pos)
```
  - getNeighbour
```
public abstract AbstractGrowthAtom getNeighbour(int pos)
```
  - getAllNeighbours
```
public abstract java.util.List getAllNeighbours()
```
  - updateOneBound
```
public abstract double updateOneBound(int bond)
```
  - isPartOfImmobilSubstrate
```
public abstract boolean isPartOfImmobilSubstrate()
```
  - hashCode
```
public int hashCode()
```
    Every atom will have an unique Id. So, we can use it as hash.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    
    hash value, based on Id.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    In general two atoms are equal if the have the same Id.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    obj - the other object. Should be atom, but can be any object.
    
    Returns:
    
    true if equals, false otherwise.
  - swapAttributes
```
public void swapAttributes(AbstractGrowthAtom atom)
```
  - updateRate
```
public double updateRate()
```
    If current atom is not eligible (thus, is immobile) return its probability in negative. Its probability is then set to zero. If the current atom is eligible, update its probability with its neighbours.
    
    Returns:
    
    probability change.
  - clear
```
public void clear()
```
    Resets current atom; TERRACE type, no neighbours, no occupied, no outside and no probability.
    
    Specified by:
    
    clear in interface IElement
  - 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.
  - remove
```
public double remove()
```
    Specified by:
    
    remove in interface IAtom
  - areTwoTerracesTogetherInPerimeter
```
public boolean areTwoTerracesTogetherInPerimeter(AbstractGrowthAtom originAtom)
```
    It has one neighbour. Check if one neighbour of the current atom is a terrace. This is useful to catch dimer formation when an atom is doing perimeter reentrance;
    
    Parameters:
    
    originAtom - has one neighbour and it is a terrace.
    
    Returns:
    
    true if a dimer is going to be created, false otherwise.
  - compareTo
```
public int compareTo(java.lang.Object o)
```
    Compares IDs of two atoms.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable
    
    Parameters:
    
    o - other atom.
    
    Returns:
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class AbstractGrowthAtom

Field Summary

Fields inherited from class kineticMonteCarlo.atom.AbstractAtom

Constructor Summary

Method Summary

Methods inherited from class kineticMonteCarlo.atom.AbstractAtom

Methods inherited from class java.lang.Object

Methods inherited from interface kineticMonteCarlo.atom.IAtom

Field Detail

type

probabilities

probability

bondsProbability

angle

outside

iHexa

jHexa

multiplier

visited

id

innerPerimeter

outerPerimeter

cartesianPosition

cartesianSuperCell

attributes

occupiedNeighbours

processes

Constructor Detail

AbstractGrowthAtom

AbstractGrowthAtom

Method Detail

getAttributes

setAttributes

getId

getiHexa

getjHexa

getCartesianPosition

setCartesianPosition

getCartesianSuperCell

setCartesianSuperCell

getAngle

setAngle

isOutside

setOutside

getType

setType

setMultiplier

getMultiplier

getBondsProbability

getBondsProbability

setBondsProbability

setBondsProbability

getProbability

resetProbability

addProbability

getProbability

getProbability

setDepositionTime

getDepositionTime

setDepositionPosition

getDepositionPosition

setHops

getHops

setIslandNumber

getIslandNumber

setMultiAtomNumber

removeMultiAtomNumber

removeMultiAtoms

getMultiAtomNumber

isVisited

setVisited

isIsolated

setInnerPerimeter

setOuterPerimeter

isInnerPerimeter

isOuterPerimeter

resetPerimeter

getOccupiedNeighbours

addOccupiedNeighbour

setProcceses