AbstractPsdEvaluator (Morphokinetics)

java.lang.Object
- geneticAlgorithm.evaluationFunctions.AbstractEvaluator
- - geneticAlgorithm.evaluationFunctions.AbstractPsdEvaluator

All Implemented Interfaces:

IEvaluation

Direct Known Subclasses:

AgBasicPsdEvaluator, BasicGrowthPsdEvaluator, MultithreadedPsdEvaluator, SiBasicPsdEvaluator
```
public abstract class AbstractPsdEvaluator
extends AbstractEvaluator
```
Author:

N. Ferrando, J. Alberdi-Rodriguez

Field Summary

Fields
Modifier and Type	Field and Description
`private Population`	`currentPopulation`
`private int`	`currentSimulation`
`private float[][]`	`difference`
`private double`	`error`
`private double`	`expectedSimulationTime`
`private float[][]`	`experimentalPsd`
`private java.util.Set`	`flags`
`private double`	`frobeniusNormOfMatrix`
`private java.lang.String`	`hierarchyEvaluator`
`private boolean`	`kmcError`
`private int`	`measureInterval`
`private float[][]`	`psd`
`private int`	`psdSizeX`
`private int`	`psdSizeY`
`private int`	`repeats`

Constructor Summary

Constructors
Constructor and Description
`AbstractPsdEvaluator(int repeats, int measureInterval, java.util.Set flags, java.lang.String hierarchyEvaluator)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`private double`	`calculateFrobeniusNorm(float[][] matrix)` It calculates Frobenius norm with the next formula: \|\|A\|\|_F = (SUM(\|A_ij\|^2))^1/2 It is useful to measure the difference among two matrices.
`double`	`calculateFrobeniusNormErrorMatrix(float[][] currentPsd)`
`protected abstract double`	`calculateHierarchyError(Individual i)`
`protected abstract double`	`calculateHierarchyErrorDiscrete(Individual ind)`
`protected abstract double`	`calculateHierarchyErrorFromReference(Individual i)`
`abstract float[][]`	`calculatePsdFromIndividual(Individual i)`
`double[]`	`evaluate(Population p)`
`private double`	`evaluateIndividual(Individual ind)`
`float[][]`	`getCurrentDifference()` Undefined here
`double`	`getCurrentError()` Undefined here
`protected int`	`getCurrentIteration()`
`Population`	`getCurrentPopulation()`
`float[][]`	`getCurrentPsd()` Undefined here
`int`	`getCurrentSimulation()`
`int`	`getIndividualCount()` Calculates the count (number) of the current simulation.
`int`	`getMeasureInterval()`
`float`	`getProgressPercent()`
`int`	`getPsdSizeX()`
`int`	`getPsdSizeY()`
`int`	`getRepeats()`
`int`	`getSimulationCount()` Undefined here
`boolean`	`hasKmcFailed()`
`void`	`kmcHasFailed()`
`private void`	`printGenes(double[] genes)`
`void`	`resetKmcError()`
`void`	`setCurrentPopulation(Population currentPopulation)`
`void`	`setCurrentSimulation(int currentSimulation)`
`void`	`setExpectedSimulationTime(double expectedSimulationTime)`
`abstract void`	`setHierarchy(double[] genes)`
`AbstractPsdEvaluator`	`setPsd(float[][] experimentalPsd)` Set the reference PSD matrix for future comparisons and starts its norms.
`void`	`setPsdSizeX(int psdSizeX)`
`void`	`setPsdSizeY(int psdSizeY)`
`void`	`setRepeats(int repeats)`

Methods inherited from class geneticAlgorithm.evaluationFunctions.AbstractEvaluator
dispose, getSurface, getWheight, setShowGraphics, setWheight, showGraphics

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

- Field Detail
  - psdSizeX
```
private int psdSizeX
```
  - psdSizeY
```
private int psdSizeY
```
  - frobeniusNormOfMatrix
```
private double frobeniusNormOfMatrix
```
  - difference
```
private float[][] difference
```
  - repeats
```
private int repeats
```
  - experimentalPsd
```
private float[][] experimentalPsd
```
  - measureInterval
```
private final int measureInterval
```
  - currentPopulation
```
private Population currentPopulation
```
  - currentSimulation
```
private int currentSimulation
```
  - expectedSimulationTime
```
private double expectedSimulationTime
```
  - error
```
private double error
```
  - psd
```
private float[][] psd
```
  - flags
```
private final java.util.Set flags
```
  - hierarchyEvaluator
```
private final java.lang.String hierarchyEvaluator
```
  - kmcError
```
private boolean kmcError
```
- Constructor Detail
  - AbstractPsdEvaluator
```
public AbstractPsdEvaluator(int repeats,
                            int measureInterval,
                            java.util.Set flags,
                            java.lang.String hierarchyEvaluator)
```
    Parameters:
    
    repeats -
    
    measureInterval -
    
    flags -
    
    hierarchyEvaluator - either "basic", "step", "reference" or "Frobenius". It is safe to assign null. It will be used only if the hierarchy flag is enabled
- Method Detail
  - setPsd
```
public AbstractPsdEvaluator setPsd(float[][] experimentalPsd)
```
    Set the reference PSD matrix for future comparisons and starts its norms.
    
    Parameters:
    
    experimentalPsd -
    
    Returns:
    
    this object
  - setExpectedSimulationTime
```
public void setExpectedSimulationTime(double expectedSimulationTime)
```
  - calculateFrobeniusNorm
```
private double calculateFrobeniusNorm(float[][] matrix)
```
    It calculates Frobenius norm with the next formula: ||A||_F = (SUM(|A_ij|^2))^1/2 It is useful to measure the difference among two matrices.
    
    Parameters:
    
    matrix -
    
    Returns:
    
    Frobenius norm
  - calculatePsdFromIndividual
```
public abstract float[][] calculatePsdFromIndividual(Individual i)
```
  - setHierarchy
```
public abstract void setHierarchy(double[] genes)
```
  - calculateHierarchyError
```
protected abstract double calculateHierarchyError(Individual i)
```
  - calculateHierarchyErrorFromReference
```
protected abstract double calculateHierarchyErrorFromReference(Individual i)
```
  - calculateHierarchyErrorDiscrete
```
protected abstract double calculateHierarchyErrorDiscrete(Individual ind)
```
  - calculateFrobeniusNormErrorMatrix
```
public double calculateFrobeniusNormErrorMatrix(float[][] currentPsd)
```
  - getProgressPercent
```
public float getProgressPercent()
```
    Specified by:
    
    getProgressPercent in interface IEvaluation
    
    Overrides:
    
    getProgressPercent in class AbstractEvaluator
  - getRepeats
```
public int getRepeats()
```
  - getMeasureInterval
```
public int getMeasureInterval()
```
  - setRepeats
```
public void setRepeats(int repeats)
```
  - getCurrentPopulation
```
public Population getCurrentPopulation()
```
  - setCurrentPopulation
```
public void setCurrentPopulation(Population currentPopulation)
```
  - getCurrentSimulation
```
public int getCurrentSimulation()
```
  - setCurrentSimulation
```
public void setCurrentSimulation(int currentSimulation)
```
  - resetKmcError
```
public void resetKmcError()
```
  - kmcHasFailed
```
public void kmcHasFailed()
```
  - hasKmcFailed
```
public boolean hasKmcFailed()
```
  - getCurrentError
```
public double getCurrentError()
```
    Description copied from class: AbstractEvaluator
    
    Undefined here
    
    Specified by:
    
    getCurrentError in interface IEvaluation
    
    Overrides:
    
    getCurrentError in class AbstractEvaluator
    
    Returns:
    
    -1
  - getCurrentPsd
```
public float[][] getCurrentPsd()
```
    Description copied from class: AbstractEvaluator
    
    Undefined here
    
    Specified by:
    
    getCurrentPsd in interface IEvaluation
    
    Overrides:
    
    getCurrentPsd in class AbstractEvaluator
    
    Returns:
    
    -1
  - getCurrentDifference
```
public float[][] getCurrentDifference()
```
    Description copied from class: AbstractEvaluator
    
    Undefined here
    
    Specified by:
    
    getCurrentDifference in interface IEvaluation
    
    Overrides:
    
    getCurrentDifference in class AbstractEvaluator
    
    Returns:
    
    -1
  - evaluate
```
public double[] evaluate(Population p)
```
  - evaluateIndividual
```
private double evaluateIndividual(Individual ind)
```
  - printGenes
```
private void printGenes(double[] genes)
```
  - setPsdSizeX
```
public final void setPsdSizeX(int psdSizeX)
```
  - setPsdSizeY
```
public final void setPsdSizeY(int psdSizeY)
```
  - getPsdSizeX
```
public final int getPsdSizeX()
```
  - getPsdSizeY
```
public final int getPsdSizeY()
```
  - getCurrentIteration
```
protected int getCurrentIteration()
```
  - getSimulationCount
```
public int getSimulationCount()
```
    Undefined here
    
    Specified by:
    
    getSimulationCount in interface IEvaluation
    
    Overrides:
    
    getSimulationCount in class AbstractEvaluator
    
    Returns:
    
    -1
  - getIndividualCount
```
public int getIndividualCount()
```
    Calculates the count (number) of the current simulation.
    
    Specified by:
    
    getIndividualCount in interface IEvaluation
    
    Overrides:
    
    getIndividualCount in class AbstractEvaluator
    
    Returns:
    
    individual count

Class AbstractPsdEvaluator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class geneticAlgorithm.evaluationFunctions.AbstractEvaluator

Methods inherited from class java.lang.Object

Field Detail

psdSizeX

psdSizeY

frobeniusNormOfMatrix

difference

repeats

experimentalPsd

measureInterval

currentPopulation

currentSimulation

expectedSimulationTime

error

psd

flags

hierarchyEvaluator

kmcError

Constructor Detail

AbstractPsdEvaluator

Method Detail

setPsd

setExpectedSimulationTime

calculateFrobeniusNorm

calculatePsdFromIndividual

setHierarchy

calculateHierarchyError

calculateHierarchyErrorFromReference

calculateHierarchyErrorDiscrete

calculateFrobeniusNormErrorMatrix

getProgressPercent

getRepeats

getMeasureInterval

setRepeats

getCurrentPopulation

setCurrentPopulation

getCurrentSimulation

setCurrentSimulation

resetKmcError

kmcHasFailed

hasKmcFailed

getCurrentError

getCurrentPsd

getCurrentDifference

evaluate

evaluateIndividual

printGenes

setPsdSizeX

setPsdSizeY

getPsdSizeX

getPsdSizeY

getCurrentIteration

getSimulationCount

getIndividualCount