Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## pipe.modules.classification
Class Classification

    java.lang.Object
      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

Field Summary
`(package private) java.awt.event.ActionListener` | `classifyButtonClick` Classify button click handler
`private static java.lang.String` | `MODULE_NAME`
`private ResultsHTMLPane` | `results`
`private PetriNetChooserPanel` | `sourceFilePanel`

Constructor Summary
`Classification()`

Method Summary
`private static int` | `cardinality(int[] X)`
`private int` | `countPlaceInputs(DataLayer pnmlData, int PlaceNo)` Counts inputs to given place
`private int` | `countPlaceOutputs(DataLayer pnmlData, int PlaceNo)`
`private int` | `countTransitionInputs(DataLayer pnmlData, int TransitionNo)`
`private int` | `countTransitionOutputs(DataLayer pnmlData, int TransitionNo)` Counts outputs from given transition
`protected boolean` | `extendedFreeChoiceNet(DataLayer pnmlData)` Extended free choice net detection
`protected boolean` | `extendedSimpleNet(DataLayer pnmlData)` Extended simple net (ESPL-net) detection
`private static boolean` | `findSubset(int[] A, int[] B)`
`private int[]` | `forwardsPlaceSet(DataLayer pnmlData, int PlaceNo)`
`protected boolean` | `freeChoiceNet(DataLayer pnmlData)` Free choice net detection
`java.lang.String` | `getName()`
`protected boolean` | `intersectionBetweenSets(int[] setOne, int[] setTwo)`
`private static boolean` | `isSubset(int[] A, int[] B)`
`protected boolean` | `markedGraph(DataLayer pnmlData)` Marked graph detection
`private static int[]` | `reduce(int[] X)`
`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`

Field Detail

### MODULE_NAME

    private static final java.lang.String MODULE_NAME

See Also:
  Constant Field Values

### sourceFilePanel

    private PetriNetChooserPanel sourceFilePanel

### results

    private ResultsHTMLPane results

### classifyButtonClick

    java.awt.event.ActionListener classifyButtonClick

  Classify button click handler

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

### countPlaceInputs

    private int countPlaceInputs(DataLayer pnmlData,
                                 int PlaceNo)

  Counts inputs to given place

  Parameters:
    `PlaceNo` -
  Returns:
    number of arcs leading to the given place number; -1 on error

### countPlaceOutputs

    private int countPlaceOutputs(DataLayer pnmlData,
                                  int PlaceNo)

### countTransitionInputs

    private int countTransitionInputs(DataLayer pnmlData,
                                      int TransitionNo)

### countTransitionOutputs

    private int countTransitionOutputs(DataLayer pnmlData,
                                       int TransitionNo)

  Counts outputs from given transition

  Returns:
    number of arcs leading from the given transition number; -1 on error

### forwardsPlaceSet

    private int[] forwardsPlaceSet(DataLayer pnmlData,
                                   int PlaceNo)

### intersectionBetweenSets

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

### isSubset

    private static boolean isSubset(int[] A,
                                    int[] B)

### reduce

    private static int[] reduce(int[] X)

### cardinality

    private static int cardinality(int[] X)

### findSubset

    private static boolean findSubset(int[] A,
                                      int[] B)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD