pipe.modules.classification
Class Classification

java.lang.Object
  extended by pipe.modules.classification.Classification
All Implemented Interfaces:
Module
Direct Known Subclasses:
GSPN

public class Classification
extends java.lang.Object
implements Module

Classification class implements petri net classification


Constructor Summary
Classification()
           
 
Method Summary
protected  boolean extendedFreeChoiceNet(DataLayer pnmlData)
          Extended free choice net detection
protected  boolean extendedSimpleNet(DataLayer pnmlData)
          Extended simple net (ESPL-net) detection
protected  boolean freeChoiceNet(DataLayer pnmlData)
          Free choice net detection
 java.lang.String getName()
           
protected  boolean intersectionBetweenSets(int[] setOne, int[] setTwo)
           
protected  boolean markedGraph(DataLayer pnmlData)
          Marked graph detection
 void run(DataLayer pnmlData)
           
protected  boolean simpleNet(DataLayer pnmlData)
          Simple net (SPL-net) detection
protected  boolean stateMachine(DataLayer pnmlData)
          State machine detection
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Classification

public Classification()
Method Detail

run

public void run(DataLayer pnmlData)
Specified by:
run in interface Module

getName

public java.lang.String getName()
Specified by:
getName in interface Module

stateMachine

protected boolean stateMachine(DataLayer pnmlData)
State machine detection

Returns:
true iff all transitions have at most one input or output SM iff ∀ t ∈ T: |•t| = |t•| ≤ 1
 P - T - P
 P - T - P   true (one input/output each)

 P - T - P
       \     false (>1 output)
         P

 P - T - P
   /         false (>1 input)
 P
 

markedGraph

protected boolean markedGraph(DataLayer pnmlData)
Marked graph detection

Returns:
true iff all places have at most one input or output MG iff ∀ p ∈ P: |•p| = |t•| ≤ 1
 T - P - T
 T - P - T   true (one input/output each)

 T - P - T
       \     false (>1 output)
         T

 T - P - T
   /         false (>1 input)
 T
 

freeChoiceNet

protected boolean freeChoiceNet(DataLayer pnmlData)
Free choice net detection

Returns:
true iff no places' outputs go to the same transition, unless those places both have only one output FC-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or |p•| = |p′•| ≤ 1)
 P - T
 P - T       true (no common outputs)
   \
     T

 P - T
   /         true (common outputs but both have only one output)
 P

 P - T
   X
 P - T       false (common outputs, both have >1 output)

 P - T
   /
 P - T       false (common outputs but one has >1 output)
 

extendedFreeChoiceNet

protected boolean extendedFreeChoiceNet(DataLayer pnmlData)
Extended free choice net detection

Returns:
true iff no places' outputs go to the same transition, unless both places outputs are identical EFC-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or p• = p′•)
 P - T
 P - T       Yes (no common outputs)
   \
     T

 P - T
   /
 P - T       No (common outputs, outputs not identical)

 P - T
   X
 P - T       Yes (common outputs identical) *** only addition to normal free choice net

 P - T       Yes (common outputs identical)
   /
 P
 

simpleNet

protected boolean simpleNet(DataLayer pnmlData)
Simple net (SPL-net) detection

Returns:
true iff no places' outputs go to the same transition, unless one of the places only has one output SPL-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or |p•| ≤ 1 or |p′•| ≤ 1)
 P - T
 P - T       true (no common outputs)
   \
     T

 P - T
   /         true (common outputs, both only have one)
 P

 P - T
   /         true (common outputs, one place has only one)
 P - T

 P - T
   X         false (common outputs, neither has only one)
 P - T

 P - T
   \
     T       false (common outputs, neither has only one)
   /
 P - T
 

extendedSimpleNet

protected boolean extendedSimpleNet(DataLayer pnmlData)
Extended simple net (ESPL-net) detection

Returns:
true iff no places' outputs go to the same transition, unless one of the places' outputs is a subset of or equal to the other's ESPL-net iff ∀ p, p′ ∈ P: p ≠ p′ ⇒ (p•∩p′• = 0 or p• ⊆ p′• or p′• ⊆ p•)
 P - T
 P - T       Yes (no common outputs)
   \
     T

 P - T
   /
 P - T       Yes (common outputs, first place's outputs is subset of second)

 P - T
   X
 P - T       Yes (common outputs, identical)

 P - T       Yes (common outputs, identical)
   /
 P

 P - T
   \
     T       false (common outputs, neither is subset of other)
   /
 P - T

     T
   /
 P - T       true (common outputs, second's is subset of first's)
   X
 P - T
 

intersectionBetweenSets

protected boolean intersectionBetweenSets(int[] setOne,
                                          int[] setTwo)