org.jbpt.petri.untangling

Class AbstractRepresentativeUntangling<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>

java.lang.Object

org.jbpt.petri.untangling.AbstractRepresentativeUntangling<BPN,C,E,F,N,P,T,M>

Direct Known Subclasses:

AbstractBaselineRepresentativeUntangling

public abstract class AbstractRepresentativeUntangling<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
extends Object

An abstract implementation of a technique for constructing representative untanglings of net system (@link INetSystem).

Author:

Artem Polyvyanyy

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	cyclic
protected Collection<IProcess<BPN,C,E,F,N,P,T,M>>	processes
protected Collection<IProcess<BPN,C,E,F,N,P,T,M>>	reducedProcesses
protected INetSystem<F,N,P,T,M>	reducedSys
protected Set<IRun<F,N,P,T,M>>	runs
protected boolean	safe
protected UntanglingSetup	setup
protected int	significantRunCounter
protected INetSystem<F,N,P,T,M>	sys
protected long	time
protected List<TreeStep<F,N,P,T,M>>	torLeaves
protected TreeStep<F,N,P,T,M>	torRoot

Constructor Summary

Constructors

Constructor and Description
AbstractRepresentativeUntangling(INetSystem<F,N,P,T,M> sys)
AbstractRepresentativeUntangling(INetSystem<F,N,P,T,M> sys, UntanglingSetup setup) Constructor of a representative untangling.

Method Summary

Methods

Modifier and Type	Method and Description
protected void	constructProcesses()
protected void	constructRuns(INetSystem<F,N,P,T,M> system) Construct maximal repetition significant runs of a given net system.
protected IProcess<BPN,C,E,F,N,P,T,M>	createProcess(INetSystem<F,N,P,T,M> sys)
protected IRun<F,N,P,T,M>	createRun(INetSystem<F,N,P,T,M> sys)
protected IUntanglingRun<F,N,P,T,M>	createUntanglingRun(INetSystem<F,N,P,T,M> sys)
Set<IRun<F,N,P,T,M>>	getMaximalSignificantRuns()
int	getNumberOfSignificantRuns()
Collection<IProcess<BPN,C,E,F,N,P,T,M>>	getProcesses()
INetSystem<F,N,P,T,M>	getReducedNetSystem()
Collection<IProcess<BPN,C,E,F,N,P,T,M>>	getReducedProcesses()
long	getTime()
boolean	isDeadlockFree()
boolean	isNonSinkDeadlockFree()
boolean	isSafe()
protected boolean	isSignificant(IRun<F,N,P,T,M> run) Check if a run of a net system is significant.
protected boolean	isSignificantCubic(IRun<F,N,P,T,M> run)
protected void	prune(IRun<F,N,P,T,M> run) Prune a given run, i.e., iteratively remove every last step of the given run if this last step occurs at least twice in this run.
protected void	reduceSubruns()
void	serializeProcesses()
void	serializeReducedProcesses()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

sys

protected INetSystem<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>> sys

reducedSys

protected INetSystem<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>> reducedSys

runs

protected Set<IRun<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>> runs

torRoot

protected TreeStep<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>> torRoot

torLeaves

protected List<TreeStep<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>> torLeaves

processes

protected Collection<IProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>> processes

reducedProcesses

protected Collection<IProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>> reducedProcesses

significantRunCounter

protected int significantRunCounter

safe

protected boolean safe

setup

protected UntanglingSetup setup

time

protected long time

cyclic

protected boolean cyclic

Constructor Detail

AbstractRepresentativeUntangling

public AbstractRepresentativeUntangling(INetSystem<F,N,P,T,M> sys)

AbstractRepresentativeUntangling

public AbstractRepresentativeUntangling(INetSystem<F,N,P,T,M> sys,
                                UntanglingSetup setup)

Constructor of a representative untangling.

Parameters:

sys - Net system to untangle.

Method Detail

getMaximalSignificantRuns

public Set<IRun<F,N,P,T,M>> getMaximalSignificantRuns()

isSafe

public boolean isSafe()

getProcesses

public Collection<IProcess<BPN,C,E,F,N,P,T,M>> getProcesses()

getReducedProcesses

public Collection<IProcess<BPN,C,E,F,N,P,T,M>> getReducedProcesses()

getReducedNetSystem

public INetSystem<F,N,P,T,M> getReducedNetSystem()

constructProcesses

protected void constructProcesses()

createProcess

protected IProcess<BPN,C,E,F,N,P,T,M> createProcess(INetSystem<F,N,P,T,M> sys)

createRun

protected IRun<F,N,P,T,M> createRun(INetSystem<F,N,P,T,M> sys)

createUntanglingRun

protected IUntanglingRun<F,N,P,T,M> createUntanglingRun(INetSystem<F,N,P,T,M> sys)

serializeProcesses

public void serializeProcesses()

serializeReducedProcesses

public void serializeReducedProcesses()

constructRuns

protected void constructRuns(INetSystem<F,N,P,T,M> system)

Construct maximal repetition significant runs of a given net system.

Parameters:

system - A net system.

isSignificant

protected boolean isSignificant(IRun<F,N,P,T,M> run)

Check if a run of a net system is significant.

Parameters:

run - A run of a net system

Returns:

true if the given run is significant; otherwise .

isSignificantCubic

protected boolean isSignificantCubic(IRun<F,N,P,T,M> run)

prune

protected void prune(IRun<F,N,P,T,M> run)

Prune a given run, i.e., iteratively remove every last step of the given run if this last step occurs at least twice in this run.

Parameters:

run - Run to prune.

getNumberOfSignificantRuns

public int getNumberOfSignificantRuns()

isDeadlockFree

public boolean isDeadlockFree()

isNonSinkDeadlockFree

public boolean isNonSinkDeadlockFree()

reduceSubruns

protected void reduceSubruns()

getTime

public long getTime()