AStar (MultiLayerAlignment)

java.lang.Object
- org.processmining.multilayeralignment.algorithms.implementations.AStar

All Implemented Interfaces:

ReplayAlgorithm

Direct Known Subclasses:

AStar.Full
```
public class AStar
extends java.lang.Object
```
Implements a variant of AStar intest path algorithm for alignments. It uses (I)LP to estimate the remaining distance. This implementation can NOT be used for prefix alignments. The final marking has to be reached as this is assumed in the underlying (I)LP.

Author:

bfvdonge

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AStar.Full
Special version of AStar that builds the entire search space, i.e.
- Nested classes/interfaces inherited from interface org.processmining.multilayeralignment.algorithms.ReplayAlgorithm
  ReplayAlgorithm.CloseResult, ReplayAlgorithm.Debug

Nested Classes
Modifier and Type	Class and Description
`static class`	`AStar.Full` Special version of AStar that builds the entire search space, i.e.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`alignmentCost`
`protected int`	`alignmentLength`
`protected int`	`alignmentResult`
`protected static byte`	`BITPERTRANSMASK`
`protected int`	`block` Stores the last block in use
`protected int`	`blockBit` Stores the number of trailing 0's in the blockSize.
`protected int`	`blockMask` equals blockSize-1
`protected int`	`blockSize` Stores the blockSize as a power of 2
`protected long`	`bytesLpSolutionsSize`
`protected int`	`bytesUsed`
`protected int`	`closedActions`
`protected static byte`	`COMPUTED`
`protected int`	`costUpperLimit`
`protected ReplayAlgorithm.Debug`	`debug` Stores the selected debug level
`protected static byte`	`DERIVED`
`protected int`	`edgesTraversed`
`protected boolean`	`enabledBlockedByCost`
`protected static byte`	`FREEBITSFIRSTBYTE`
`protected static int`	`HEURISTICINFINITE`
`protected int`	`heuristicsComputed`
`protected int`	`heuristicsDerived`
`protected int`	`heuristicsEstimated`
`protected int`	`indexInBlock` Stores the first new index in current block
`protected int`	`iteration`
`protected gnu.trove.map.TIntObjectMap<byte[]>`	`lpSolutions`
`protected long`	`lpSolutionsSize`
`protected int`	`markingsReached`
`protected int`	`maximumNumberOfStates`
`protected int`	`maxMapCapacity`
`protected boolean`	`moveSorting` Indicate if moves should be considered totally ordered.
`protected SyncProduct`	`net` The synchronous product under investigation
`protected static int`	`NOPREDECESSOR`
`protected int`	`numPlaces`
`protected int`	`pollActions`
`protected boolean`	`preferExact` Flag indicating if exact solutions should be kept separate
`protected Queue`	`queue` Stores the open set as a priority queue
`protected int`	`queueActions`
`protected gnu.trove.map.TObjectIntMap<Utils.Statistic>`	`replayStatistics`
`protected static int`	`RESTART`
`protected double[]`	`rhf`
`protected int`	`runTime`
`protected int`	`setupTime`
`protected lpsolve.LpSolve`	`solver`
`protected long`	`solveTime`
`protected long`	`startConstructor`
`protected int[]`	`tempForSettingSolution`
`protected long`	`timeoutAtTimeInMillisecond`
`protected double[]`	`varsMainThread`
`protected VisitedSet`	`visited` Stores the closed set

Constructor Summary

Constructors
Constructor and Description
`AStar(SyncProduct product)`
`AStar(SyncProduct product, boolean moveSorting, boolean queueSorting, boolean preferExact, boolean isInteger, ReplayAlgorithm.Debug debug)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`addNewMarking(byte[] marking)` Adds a new marking to the internal storage.
`protected void`	`addToQueue(int marking)`
`protected ReplayAlgorithm.CloseResult`	`closeOrUpdateMarking(int m, byte[] marking_m, int bm, int im)`
`protected double`	`computeCostForVars(double[] vars)`
`protected void`	`deriveOrEstimateHValue(int from, int fromBlock, int fromIndex, int transition, int to, int toBlock, int toIndex)`
`boolean`	`equalMarking(int marking1, byte[] marking2)` Checks equality of the stored marking1 to the given marking2.
`protected int`	`expandMarking(int m, byte[] marking_m, int bm, int im)`
`protected void`	`fillMarking(byte[] markingArray, int marking)`
`protected void`	`fillStatistics(int[] alignment)`
`protected void`	`fire(byte[] marking, int transition)`
`protected byte[]`	`fire(byte[] fromMarking, int transition, int block, int index)`
`protected int[]`	`getAlignmentWhenEmptyQueueReached(long startTime)`
`long`	`getEstimatedMemorySize()` Estimates the memory size of the internal data structures in bytes.
`int`	`getExactHeuristic(int marking, byte[] markingArray, int markingBlock, int markingIndex)` Returns the h score for the given marking
`int`	`getFScore(int marking)` Returns the f score for a stored marking
`int`	`getFScore(int block, int index)` Returns the f score for a stored marking
`int`	`getGScore(int marking)` Returns the g score for a stored marking
`int`	`getGScore(int block, int index)` Returns the g score for a stored marking
`int`	`getHScore(int marking)` Returns the h score for a stored marking
`int`	`getHScore(int block, int index)` Returns the h score for a stored marking
`int`	`getIterationNumber()` Returns the current iteration number of the algorithm if there are multiple iterations in which the same marking IDs will be present.
`int`	`getLastRankOf(int marking)` Returns the highest rank of an event explained by the path through which the stored marking with ID markingId was reached.
`protected int`	`getLpSolution(int marking, int transition)`
`byte[]`	`getMarking(int marking)` Returns the explicit representation of the marking stored with ID markingId.
`SyncProduct`	`getNet()` Returns the synchronous product for which this ReplayAlgorithm was instantiated
`int`	`getPathLength(int marking)` returns the length of the path from the initial marking to reach this marking
`int`	`getPredecessor(int marking)` Returns the predecessor for a stored marking
`int`	`getPredecessor(int block, int index)` Returns the predecessor for a stored marking
`int`	`getPredecessorTransition(int marking)` Returns the predecessor transition for a stored marking
`int`	`getPredecessorTransition(int block, int index)` Returns the predecessor transition for a stored marking
`gnu.trove.map.TObjectIntMap<Utils.Statistic>`	`getStatistics()` Obtain the statistics after computing an alignment.
`protected void`	`growArrays()` Grow the internal array structure.
`protected int[]`	`handleFinalMarkingReached(long startTime, int marking)`
`boolean`	`hasExactHeuristic(int marking)` returns true if the heuristic stored for the given marking is exact or an estimate.
`boolean`	`hasExactHeuristic(int block, int index)` returns true if the heuristic stored for the given marking is exact or an estimate.
`int`	`hashCode(byte[] marking)` Returns the hashCode of a stored marking which is provided as an array of length 2*bm, where the first bm bytes provide the low bits and the second bm bytes provide the high bits.
`int`	`hashCode(int marking)` Returns the hashCode of a stored marking
`boolean`	`hasPlaceBetween(int preTransition, int transition)` returns true if there is a place common in the output set of transitionFrom and the input set of transitionTo
`protected void`	`initializeIteration()`
`protected void`	`initializeIterationInternal()`
`boolean`	`isClosed(int marking)` Returns true if marking is in the closed set
`boolean`	`isClosed(int block, int index)` Returns the g score for a stored marking
`protected boolean`	`isDerivedLpSolution(int marking)`
`protected boolean`	`isEnabled(byte[] marking, int transition, int block, int index)`
`protected boolean`	`isFinal(int marking)` In ILP version, only one given final marking is the target.
`boolean`	`isInfinite(int heur)` Checks if a value for the h-score is INFINITE.
`protected void`	`processedMarking(int marking, int blockMarking, int indexInBlock)`
`void`	`putStatistic(Utils.Statistic stat, int value)` Adds a statistic to the set of statistics.
`int[]`	`run(nl.tue.alignment.Canceler canceller, int timeoutMilliseconds, int maximumNumberOfStates, int costUpperLimit)` Run the replay algorithm.
`protected int[]`	`runReplayAlgorithm(nl.tue.alignment.Canceler canceller, long startTime, int timeoutMilliseconds)`
`void`	`setClosed(int marking)` Set the g score for a stored marking
`void`	`setClosed(int block, int index)` Set the g score for a stored marking
`protected void`	`setDerivedLpSolution(int from, int to, int transition)`
`void`	`setGScore(int marking, int score)` Set the g score for a stored marking
`void`	`setGScore(int block, int index, int score)` Set the g score for a stored marking
`void`	`setHScore(int marking, int score, boolean isExact)` Set the h score for a stored marking
`void`	`setHScore(int block, int index, int score, boolean isExact)` set the h score for a stored marking
`protected void`	`setNewLpSolution(int marking, double[] solutionDouble)`
`protected void`	`setNewLpSolution(int marking, int bits, int[] solutionInt)` Stores the solution vector.
`void`	`setPredecessor(int marking, int predecessorMarking)` Sets the predecessor for a stored marking
`void`	`setPredecessor(int block, int index, int predecessorMarking)` Sets the predecessor for a stored marking
`void`	`setPredecessorTransition(int marking, int transition)` Sets the predecessor transition for a stored marking
`void`	`setPredecessorTransition(int block, int index, int transition)` Sets the predecessor transition for a stored marking
`protected void`	`terminateIteration(int[] alignment, int markingsReachedInRun, int closedActionsInRun)`
`protected void`	`writeEdgeTraversed(ReplayAlgorithm algorithm, int fromMarking, int transition, int toMarking, java.lang.String extra)`
`protected void`	`writeEndOfAlignmentDot(int[] alignment, int markingsReachedInRun, int closedActionsInRun)`
`protected void`	`writeEndOfAlignmentNormal(int[] alignment, int markingsReachedInRun, int closedActionsInRun)`
`protected void`	`writeEndOfAlignmentStats(int[] alignment, int markingsReachedInRun, int closedActionsInRun)`
`protected void`	`writeStatus()`

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

- Field Detail
  - rhf
```
protected final double[] rhf
```
  - varsMainThread
```
protected double[] varsMainThread
```
  - COMPUTED
```
protected static final byte COMPUTED
```
    See Also:
    
    Constant Field Values
  - DERIVED
```
protected static final byte DERIVED
```
    See Also:
    
    Constant Field Values
  - BITPERTRANSMASK
```
protected static final byte BITPERTRANSMASK
```
    See Also:
    
    Constant Field Values
  - FREEBITSFIRSTBYTE
```
protected static final byte FREEBITSFIRSTBYTE
```
    See Also:
    
    Constant Field Values
  - maxMapCapacity
```
protected int maxMapCapacity
```
  - lpSolutions
```
protected gnu.trove.map.TIntObjectMap<byte[]> lpSolutions
```
  - lpSolutionsSize
```
protected long lpSolutionsSize
```
  - bytesLpSolutionsSize
```
protected long bytesLpSolutionsSize
```
  - solver
```
protected lpsolve.LpSolve solver
```
  - bytesUsed
```
protected int bytesUsed
```
  - solveTime
```
protected long solveTime
```
  - tempForSettingSolution
```
protected int[] tempForSettingSolution
```
  - RESTART
```
protected static final int RESTART
```
    See Also:
    
    Constant Field Values
  - visited
```
protected VisitedSet visited
```
    Stores the closed set
  - net
```
protected final SyncProduct net
```
    The synchronous product under investigation
  - queue
```
protected Queue queue
```
    Stores the open set as a priority queue
  - moveSorting
```
protected boolean moveSorting
```
    Indicate if moves should be considered totally ordered.
  - debug
```
protected final ReplayAlgorithm.Debug debug
```
    Stores the selected debug level
  - preferExact
```
protected final boolean preferExact
```
    Flag indicating if exact solutions should be kept separate
  - pollActions
```
protected int pollActions
```
  - closedActions
```
protected int closedActions
```
  - queueActions
```
protected int queueActions
```
  - edgesTraversed
```
protected int edgesTraversed
```
  - enabledBlockedByCost
```
protected boolean enabledBlockedByCost
```
  - markingsReached
```
protected int markingsReached
```
  - heuristicsComputed
```
protected int heuristicsComputed
```
  - heuristicsEstimated
```
protected int heuristicsEstimated
```
  - heuristicsDerived
```
protected int heuristicsDerived
```
  - alignmentLength
```
protected int alignmentLength
```
  - alignmentCost
```
protected int alignmentCost
```
  - setupTime
```
protected int setupTime
```
  - runTime
```
protected int runTime
```
  - iteration
```
protected int iteration
```
  - startConstructor
```
protected long startConstructor
```
  - numPlaces
```
protected int numPlaces
```
  - timeoutAtTimeInMillisecond
```
protected long timeoutAtTimeInMillisecond
```
  - maximumNumberOfStates
```
protected int maximumNumberOfStates
```
  - costUpperLimit
```
protected int costUpperLimit
```
  - replayStatistics
```
protected gnu.trove.map.TObjectIntMap<Utils.Statistic> replayStatistics
```
  - HEURISTICINFINITE
```
protected static int HEURISTICINFINITE
```
  - NOPREDECESSOR
```
protected static final int NOPREDECESSOR
```
    See Also:
    
    Constant Field Values
  - alignmentResult
```
protected int alignmentResult
```
  - blockSize
```
protected final int blockSize
```
    Stores the blockSize as a power of 2
  - blockBit
```
protected final int blockBit
```
    Stores the number of trailing 0's in the blockSize.
  - blockMask
```
protected final int blockMask
```
    equals blockSize-1
  - block
```
protected int block
```
    Stores the last block in use
  - indexInBlock
```
protected int indexInBlock
```
    Stores the first new index in current block
- Constructor Detail
  - AStar
```
public AStar(SyncProduct product)
      throws nl.tue.astar.util.ilp.LPMatrixException
```
    Throws:
    
    nl.tue.astar.util.ilp.LPMatrixException
  - AStar
```
public AStar(SyncProduct product,
             boolean moveSorting,
             boolean queueSorting,
             boolean preferExact,
             boolean isInteger,
             ReplayAlgorithm.Debug debug)
      throws nl.tue.astar.util.ilp.LPMatrixException
```
    Throws:
    
    nl.tue.astar.util.ilp.LPMatrixException
- Method Detail
  - initializeIteration
```
protected void initializeIteration()
                            throws nl.tue.astar.util.ilp.LPMatrixException
```
    Throws:
    
    nl.tue.astar.util.ilp.LPMatrixException - in subclasses using (I)LP
  - growArrays
```
protected void growArrays()
```
    Grow the internal array structure. Method should be considered synchronized as it should not be executed in parallel.
  - getExactHeuristic
```
public int getExactHeuristic(int marking,
                             byte[] markingArray,
                             int markingBlock,
                             int markingIndex)
```
    Returns the h score for the given marking
    
    Returns:
  - computeCostForVars
```
protected double computeCostForVars(double[] vars)
```
  - deriveOrEstimateHValue
```
protected void deriveOrEstimateHValue(int from,
                                      int fromBlock,
                                      int fromIndex,
                                      int transition,
                                      int to,
                                      int toBlock,
                                      int toIndex)
```
  - getEstimatedMemorySize
```
public long getEstimatedMemorySize()
```
    Description copied from interface: ReplayAlgorithm
    
    Estimates the memory size of the internal data structures in bytes.
    
    Specified by:
    
    getEstimatedMemorySize in interface ReplayAlgorithm
    
    Returns:
    
    The estimated memory size of the internal data structures in bytes.
  - fillStatistics
```
protected void fillStatistics(int[] alignment)
```
  - writeEndOfAlignmentDot
```
protected void writeEndOfAlignmentDot(int[] alignment,
                                      int markingsReachedInRun,
                                      int closedActionsInRun)
```
  - processedMarking
```
protected void processedMarking(int marking,
                                int blockMarking,
                                int indexInBlock)
```
  - setNewLpSolution
```
protected void setNewLpSolution(int marking,
                                double[] solutionDouble)
```
  - setNewLpSolution
```
protected void setNewLpSolution(int marking,
                                int bits,
                                int[] solutionInt)
```
    Stores the solution vector. This vector should be on the move level!
    
    Parameters:
    
    marking -
    
    bits -
    
    solutionInt -
  - getLpSolution
```
protected int getLpSolution(int marking,
                            int transition)
```
  - isDerivedLpSolution
```
protected boolean isDerivedLpSolution(int marking)
```
  - setDerivedLpSolution
```
protected void setDerivedLpSolution(int from,
                                    int to,
                                    int transition)
```
  - isFinal
```
protected boolean isFinal(int marking)
```
    In ILP version, only one given final marking is the target.
  - terminateIteration
```
protected void terminateIteration(int[] alignment,
                                  int markingsReachedInRun,
                                  int closedActionsInRun)
```
  - writeEdgeTraversed
```
protected void writeEdgeTraversed(ReplayAlgorithm algorithm,
                                  int fromMarking,
                                  int transition,
                                  int toMarking,
                                  java.lang.String extra)
```
  - getStatistics
```
public gnu.trove.map.TObjectIntMap<Utils.Statistic> getStatistics()
```
    Description copied from interface: ReplayAlgorithm
    
    Obtain the statistics after computing an alignment. Should only be called after a call to run();
    
    Returns:
  - run
```
public int[] run(nl.tue.alignment.Canceler canceller,
                 int timeoutMilliseconds,
                 int maximumNumberOfStates,
                 int costUpperLimit)
          throws nl.tue.astar.util.ilp.LPMatrixException
```
    Description copied from interface: ReplayAlgorithm
    
    Run the replay algorithm. The canceler is provided for cancellation purposes. A timeout is specified in milliseconds and a maximum number of states is also provided. Furthermore, as cost upper limit can be given to bound the search.
    
    Parameters:
    
    canceller - Allows for canceling the computation
    
    timeoutMilliseconds - Timeout for the computation
    
    maximumNumberOfStates - Maximum number of states expanded
    
    costUpperLimit - Maximum cost of the alignment. Providing an upperbound of 0 will answer the yes/no question if the trace is fitting (assuming synchronous and tau-moves have cost 0)
    
    Returns:
    
    alignment as a sequence of transition firings from the initial marking to (1) the final marking if the computation is succesful or (2) any marking if it is not succesful
    
    Throws:
    
    nl.tue.astar.util.ilp.LPMatrixException - Exceptions is thrown if there is a problem with the LP computations.
  - runReplayAlgorithm
```
protected int[] runReplayAlgorithm(nl.tue.alignment.Canceler canceller,
                                   long startTime,
                                   int timeoutMilliseconds)
                            throws nl.tue.astar.util.ilp.LPMatrixException
```
    Throws:
    
    nl.tue.astar.util.ilp.LPMatrixException
  - getAlignmentWhenEmptyQueueReached
```
protected int[] getAlignmentWhenEmptyQueueReached(long startTime)
```
  - expandMarking
```
protected int expandMarking(int m,
                            byte[] marking_m,
                            int bm,
                            int im)
```
  - closeOrUpdateMarking
```
protected ReplayAlgorithm.CloseResult closeOrUpdateMarking(int m,
                                                           byte[] marking_m,
                                                           int bm,
                                                           int im)
```
  - initializeIterationInternal
```
protected void initializeIterationInternal()
```
  - addToQueue
```
protected void addToQueue(int marking)
```
  - handleFinalMarkingReached
```
protected int[] handleFinalMarkingReached(long startTime,
                                          int marking)
```
  - writeEndOfAlignmentStats
```
protected void writeEndOfAlignmentStats(int[] alignment,
                                        int markingsReachedInRun,
                                        int closedActionsInRun)
```
  - writeEndOfAlignmentNormal
```
protected void writeEndOfAlignmentNormal(int[] alignment,
                                         int markingsReachedInRun,
                                         int closedActionsInRun)
```
  - fire
```
protected byte[] fire(byte[] fromMarking,
                      int transition,
                      int block,
                      int index)
```
  - fire
```
protected void fire(byte[] marking,
                    int transition)
```
  - isEnabled
```
protected boolean isEnabled(byte[] marking,
                            int transition,
                            int block,
                            int index)
```
  - hasPlaceBetween
```
public boolean hasPlaceBetween(int preTransition,
                               int transition)
```
    returns true if there is a place common in the output set of transitionFrom and the input set of transitionTo
    
    Parameters:
    
    transitionFrom -
    
    transitionTo -
    
    Returns:
  - getMarking
```
public byte[] getMarking(int marking)
```
    Description copied from interface: ReplayAlgorithm
    
    Returns the explicit representation of the marking stored with ID markingId.
    
    Parameters:
    
    marking - an ID of a previously stored marking (ID obtained through addNewMarking())
    
    Returns:
    
    the explicit representation of the marking
  - fillMarking
```
protected void fillMarking(byte[] markingArray,
                           int marking)
```
  - addNewMarking
```
public int addNewMarking(byte[] marking)
```
    Description copied from interface: ReplayAlgorithm
    
    Adds a new marking to the internal storage. Method should only be called if it does not exist already.
    
    Parameters:
    
    marking - the byte[] indicating the number of tokens per place
    
    Returns:
    
    the id of the marking in the internal storage.
  - writeStatus
```
protected void writeStatus()
```
  - equalMarking
```
public boolean equalMarking(int marking1,
                            byte[] marking2)
```
    Checks equality of the stored marking1 to the given marking2.
    
    Parameters:
    
    marking1 -
    
    marking2 -
    
    Returns:
    
    See Also:
    
    SyncProduct.getInitialMarking();
  - hashCode
```
public int hashCode(int marking)
```
    Returns the hashCode of a stored marking
    
    Parameters:
    
    marking -
    
    Returns:
  - hashCode
```
public int hashCode(byte[] marking)
```
    Returns the hashCode of a stored marking which is provided as an array of length 2*bm, where the first bm bytes provide the low bits and the second bm bytes provide the high bits.
    
    Parameters:
    
    marking -
    
    Returns:
    
    See Also:
    
    SyncProduct.getInitialMarking();
  - getNet
```
public SyncProduct getNet()
```
    Description copied from interface: ReplayAlgorithm
    
    Returns the synchronous product for which this ReplayAlgorithm was instantiated
    
    Returns:
    
    the synchronous product
  - getLastRankOf
```
public int getLastRankOf(int marking)
```
    Description copied from interface: ReplayAlgorithm
    
    Returns the highest rank of an event explained by the path through which the stored marking with ID markingId was reached.
    
    Parameters:
    
    marking - an ID of a previously stored marking (ID obtained through addNewMarking()
    
    Returns:
    
    the highest rank of any event explained by a path to this marking.
  - putStatistic
```
public void putStatistic(Utils.Statistic stat,
                         int value)
```
    Description copied from interface: ReplayAlgorithm
    
    Adds a statistic to the set of statistics. Can be called before or after run(), but the run() method may overwrite previously added statistics.
  - getIterationNumber
```
public int getIterationNumber()
```
    Description copied from interface: ReplayAlgorithm
    
    Returns the current iteration number of the algorithm if there are multiple iterations in which the same marking IDs will be present. This method is needed for DOT output to separate the nodes in the iterations.
    
    Returns:
    
    the iteration number
  - getPathLength
```
public int getPathLength(int marking)
```
    Description copied from interface: ReplayAlgorithm
    
    returns the length of the path from the initial marking to reach this marking
    
    Returns:
  - getGScore
```
public int getGScore(int block,
                     int index)
```
    Returns the g score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - setGScore
```
public void setGScore(int block,
                      int index,
                      int score)
```
    Set the g score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
  - setGScore
```
public void setGScore(int marking,
                      int score)
```
    Set the g score for a stored marking
    
    Parameters:
    
    marking -
  - getHScore
```
public int getHScore(int marking)
```
    Returns the h score for a stored marking
    
    Specified by:
    
    getHScore in interface ReplayAlgorithm
    
    Parameters:
    
    marking -
    
    Returns:
  - getHScore
```
public int getHScore(int block,
                     int index)
```
    Returns the h score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - setHScore
```
public void setHScore(int block,
                      int index,
                      int score,
                      boolean isExact)
```
    set the h score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
  - setHScore
```
public void setHScore(int marking,
                      int score,
                      boolean isExact)
```
    Set the h score for a stored marking
    
    Parameters:
    
    marking -
  - getPredecessor
```
public int getPredecessor(int marking)
```
    Returns the predecessor for a stored marking
    
    Parameters:
    
    marking -
    
    Returns:
  - getPredecessor
```
public int getPredecessor(int block,
                          int index)
```
    Returns the predecessor for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - setPredecessor
```
public void setPredecessor(int block,
                           int index,
                           int predecessorMarking)
```
    Sets the predecessor for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
  - setPredecessor
```
public void setPredecessor(int marking,
                           int predecessorMarking)
```
    Sets the predecessor for a stored marking
    
    Parameters:
    
    marking -
  - getPredecessorTransition
```
public int getPredecessorTransition(int marking)
```
    Returns the predecessor transition for a stored marking
    
    Parameters:
    
    marking -
    
    Returns:
  - getPredecessorTransition
```
public int getPredecessorTransition(int block,
                                    int index)
```
    Returns the predecessor transition for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - setPredecessorTransition
```
public void setPredecessorTransition(int block,
                                     int index,
                                     int transition)
```
    Sets the predecessor transition for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
  - setPredecessorTransition
```
public void setPredecessorTransition(int marking,
                                     int transition)
```
    Sets the predecessor transition for a stored marking
    
    Parameters:
    
    marking -
  - isClosed
```
public boolean isClosed(int marking)
```
    Returns true if marking is in the closed set
    
    Specified by:
    
    isClosed in interface ReplayAlgorithm
    
    Parameters:
    
    marking -
    
    Returns:
  - isClosed
```
public boolean isClosed(int block,
                        int index)
```
    Returns the g score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - setClosed
```
public void setClosed(int block,
                      int index)
```
    Set the g score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
  - setClosed
```
public void setClosed(int marking)
```
    Set the g score for a stored marking
    
    Parameters:
    
    marking -
  - getFScore
```
public int getFScore(int marking)
```
    Returns the f score for a stored marking
    
    Specified by:
    
    getFScore in interface ReplayAlgorithm
    
    Parameters:
    
    marking -
    
    Returns:
  - getFScore
```
public int getFScore(int block,
                     int index)
```
    Returns the f score for a stored marking
    
    Parameters:
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - getGScore
```
public int getGScore(int marking)
```
    Returns the g score for a stored marking
    
    Specified by:
    
    getGScore in interface ReplayAlgorithm
    
    Parameters:
    
    marking -
    
    Returns:
  - hasExactHeuristic
```
public boolean hasExactHeuristic(int marking)
```
    returns true if the heuristic stored for the given marking is exact or an estimate.
    
    Specified by:
    
    hasExactHeuristic in interface ReplayAlgorithm
    
    Parameters:
    
    marking -
    
    Returns:
  - hasExactHeuristic
```
public boolean hasExactHeuristic(int block,
                                 int index)
```
    returns true if the heuristic stored for the given marking is exact or an estimate.
    
    Parameters:
    
    marking -
    
    block - the memory block the marking is stored in
    
    index - the index at which the marking is stored in the memory block
    
    Returns:
  - isInfinite
```
public boolean isInfinite(int heur)
```
    Description copied from interface: ReplayAlgorithm
    
    Checks if a value for the h-score is INFINITE.
    
    Specified by:
    
    isInfinite in interface ReplayAlgorithm
    
    Parameters:
    
    heur - a value for the h-score
    
    Returns:
    
    true if the provided value is considered INFINITE

Class AStar

Nested Class Summary

Nested classes/interfaces inherited from interface org.processmining.multilayeralignment.algorithms.ReplayAlgorithm

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

rhf

varsMainThread

COMPUTED

DERIVED

BITPERTRANSMASK

FREEBITSFIRSTBYTE

maxMapCapacity

lpSolutions

lpSolutionsSize

bytesLpSolutionsSize

solver

bytesUsed

solveTime

tempForSettingSolution

RESTART

visited

net

queue

moveSorting

debug

preferExact

pollActions

closedActions

queueActions

edgesTraversed

enabledBlockedByCost

markingsReached

heuristicsComputed

heuristicsEstimated

heuristicsDerived

alignmentLength

alignmentCost

setupTime

runTime

iteration

startConstructor

numPlaces

timeoutAtTimeInMillisecond

maximumNumberOfStates

costUpperLimit

replayStatistics

HEURISTICINFINITE

NOPREDECESSOR

alignmentResult

blockSize

blockBit

blockMask

block

indexInBlock

Constructor Detail

AStar

AStar

Method Detail

initializeIteration

growArrays

getExactHeuristic

computeCostForVars

deriveOrEstimateHValue

getEstimatedMemorySize

fillStatistics

writeEndOfAlignmentDot

processedMarking

setNewLpSolution

setNewLpSolution

getLpSolution

isDerivedLpSolution

setDerivedLpSolution

isFinal

terminateIteration

writeEdgeTraversed

getStatistics

run