Make PlacesProvider not always depend on an event log and give a PlacesProviderFactory instead to the PlaceBasedLPMDiscovery

Author: VikiPeeva

src/org/processmining/lpms/discovery/DiscoveryParameters.java

@@ -1,6 +1,10 @@
 package org.processmining.lpms.discovery;
 
 public class DiscoveryParameters {
+    public static class PlaceBased {
+        public static int placeLimit = 100;
+    }
+
     public static class Default {
         public static int proximity = 7;
     }

src/org/processmining/placebasedlpmdiscovery/lpmdiscovery/LPMDiscovery.java

@@ -8,21 +8,25 @@
 public interface LPMDiscovery {
 
     static LPMDiscovery getInstance() {
-        return placeBased(PlacesProvider.getInstance(), 100);
+        return placeBased();
     }
 
-    static LPMDiscovery treeBased() {return new ProcessTreeBasedLPMDiscovery(); }
+    static LPMDiscovery treeBased() { return new ProcessTreeBasedLPMDiscovery(); }
+
+    static LPMDiscovery placeBased() {
+        return new PlaceBasedLPMDiscovery(PlacesProvider::fromLog);
+    }
 
     static LPMDiscovery placeBased(PlacesProvider placesProvider) {
-        return new PlaceBasedLPMDiscovery(placesProvider);
+        return new PlaceBasedLPMDiscovery((XLog log) -> placesProvider);
     }
 
     static LPMDiscovery placeBased(PlacesProvider placesProvider, int placeLimit) {
-        return new PlaceBasedLPMDiscovery(placesProvider, placeLimit);
+        return new PlaceBasedLPMDiscovery((XLog log) -> placesProvider, placeLimit);
     }
 
     static LPMDiscovery placeBased(PlacesProvider placesProvider, int placeLimit, int concurrencyLimit) {
-        return new PlaceBasedLPMDiscovery(placesProvider, placeLimit, concurrencyLimit);
+        return new PlaceBasedLPMDiscovery((XLog log) -> placesProvider, placeLimit, concurrencyLimit);
     }
 
     static LPMDiscovery ladaBased(int proximityLimit) {

src/org/processmining/placebasedlpmdiscovery/lpmdiscovery/PlaceBasedLPMDiscovery.java

@@ -11,32 +11,31 @@
 import org.processmining.placebasedlpmdiscovery.model.discovery.LPMDiscoveryResult;
 import org.processmining.placebasedlpmdiscovery.model.logs.EventLog;
 import org.processmining.placebasedlpmdiscovery.model.logs.XLogWrapper;
-import org.processmining.placebasedlpmdiscovery.prom.PlacesProvider;
+import org.processmining.placebasedlpmdiscovery.prom.PlacesProviderFactory;
 
 import java.util.Set;
 
 public class PlaceBasedLPMDiscovery implements LPMDiscovery {
 
     private final int placeLimit;
-    private final PlacesProvider placesProvider;
+    private final PlacesProviderFactory placesProviderFactory;
     private final int proximity;
     private final int concurrencyLimit;
 
-
-    public PlaceBasedLPMDiscovery(PlacesProvider placesProvider) {
-        this(placesProvider, 50);
+    public PlaceBasedLPMDiscovery(PlacesProviderFactory placesProviderFactory) {
+        this(placesProviderFactory, DiscoveryParameters.PlaceBased.placeLimit);
     }
 
-    public PlaceBasedLPMDiscovery(PlacesProvider placesProvider, int placeLimit) {
-        this(placesProvider, placeLimit, DiscoveryParameters.Default.proximity);
+    public PlaceBasedLPMDiscovery(PlacesProviderFactory placesProviderFactory, int placeLimit) {
+        this(placesProviderFactory, placeLimit, DiscoveryParameters.Default.proximity);
     }
 
-    public PlaceBasedLPMDiscovery(PlacesProvider placesProvider, int placeLimit, int proximity) {
-        this(placesProvider, placeLimit, proximity, 2);
+    public PlaceBasedLPMDiscovery(PlacesProviderFactory placesProviderFactory, int placeLimit, int proximity) {
+        this(placesProviderFactory, placeLimit, proximity, 2);
     }
 
-    public PlaceBasedLPMDiscovery(PlacesProvider placesProvider, int placeLimit, int proximity, int concurrencyLimit) {
-        this.placesProvider = placesProvider;
+    public PlaceBasedLPMDiscovery(PlacesProviderFactory placesProviderFactory, int placeLimit, int proximity, int concurrencyLimit) {
+        this.placesProviderFactory = placesProviderFactory;
         this.placeLimit = placeLimit;
         this.proximity = proximity;
         this.concurrencyLimit = concurrencyLimit;
@@ -52,7 +51,7 @@ public LPMDiscoveryResult from(XLog log) {
         parameters.getLpmCombinationParameters().setConcurrencyCardinality(this.concurrencyLimit);
 
         LPMDiscoveryAlgBuilder builder = Main.createDefaultBuilder(log, parameters);
-        Set<Place> places = this.placesProvider.from(log);
+        Set<Place> places = this.placesProviderFactory.create(log).provide();
 
         FPGrowthForPlacesLPMBuildingInput lpmBuildingInput = new FPGrowthForPlacesLPMBuildingInput(eventLog, places);
         StandardLPMDiscoveryInput discoveryInput =

src/org/processmining/placebasedlpmdiscovery/prom/DiscoveryPlacesProvider.java

@@ -1,6 +1,5 @@
 package org.processmining.placebasedlpmdiscovery.prom;
 
-import org.deckfour.xes.model.XLog;
 import org.processmining.models.graphbased.directed.petrinet.Petrinet;
 import org.processmining.placebasedlpmdiscovery.model.Place;
 import org.processmining.placebasedlpmdiscovery.model.exporting.importers.ImporterFactory;
@@ -23,7 +22,7 @@ public FromFilePlacesProvider(String fileName) {
     }
 
     @Override
-    public Set<Place> from(XLog log) {
+    public Set<Place> provide() {
         try {
             if (this.fileName.endsWith("pnml")) {
                 Petrinet net = PlaceUtils.extractPetriNet(fileName);

src/org/processmining/placebasedlpmdiscovery/prom/FromFilePlacesProvider.java

@@ -0,0 +1,58 @@
+package org.processmining.placebasedlpmdiscovery.prom;
+
+import org.deckfour.xes.model.XLog;
+import org.processmining.placebasedlpmdiscovery.model.Place;
+import org.processmining.placebasedlpmdiscovery.prom.placediscovery.algorithms.PlaceDiscoveryAlgorithm;
+import org.processmining.placebasedlpmdiscovery.prom.placediscovery.algorithms.PlaceDiscoveryAlgorithmFactory;
+import org.processmining.placebasedlpmdiscovery.prom.placediscovery.parameters.EstMinerPlaceDiscoveryParameters;
+import org.processmining.placebasedlpmdiscovery.prom.placediscovery.parameters.SPECppPlaceDiscoveryParameters;
+
+import java.util.Set;
+
+public class FromLogPlacesProvider implements PlacesProvider {
+
+    private final XLog log;
+    private final PlaceDiscoveryAlgorithm<?, ?> algorithm;
+
+    public FromLogPlacesProvider(XLog log, PlaceDiscoveryAlgorithm<?, ?> algorithm) {
+        this.log = log;
+        this.algorithm = algorithm;
+    }
+
+    @Override
+    public Set<Place> provide() {
+        return algorithm.getPlaces(this.log).getPlaces();
+    }
+
+    /**
+     * Creates a PlacesProvider that discovers places using the recommended algorithm (SPECpp).
+     * @param log the XLog to discover places from
+     * @return a PlacesProvider that discovers places using the recommended algorithm
+     */
+    public static PlacesProvider recommended(XLog log) {
+        return specpp(log);
+    }
+
+    /**
+     * Creates a PlacesProvider that discovers places using the EST-Miner algorithm.
+     * @param log the XLog to discover places from
+     * @return a PlacesProvider that discovers places using the EST-Miner algorithm
+     */
+    public static PlacesProvider est(XLog log) {
+        PlaceDiscoveryAlgorithmFactory factory = new PlaceDiscoveryAlgorithmFactory();
+        EstMinerPlaceDiscoveryParameters parameters = new EstMinerPlaceDiscoveryParameters();
+        return new FromLogPlacesProvider(log, parameters.getAlgorithm(factory));
+    }
+
+    /**
+     * Creates a PlacesProvider that discovers places using the SPECpp algorithm.
+     * @param log the XLog to discover places from
+     * @return a PlacesProvider that discovers places using the SPECpp algorithm
+     */
+    public static PlacesProvider specpp(XLog log) {
+        PlaceDiscoveryAlgorithmFactory factory = new PlaceDiscoveryAlgorithmFactory();
+        SPECppPlaceDiscoveryParameters parameters = new SPECppPlaceDiscoveryParameters();
+        return new FromLogPlacesProvider(log, parameters.getAlgorithm(factory));
+    }
+
+}

src/org/processmining/placebasedlpmdiscovery/prom/FromLogPlacesProvider.java

@@ -2,37 +2,45 @@
 
 import org.deckfour.xes.model.XLog;
 import org.processmining.placebasedlpmdiscovery.model.Place;
-import org.processmining.placebasedlpmdiscovery.prom.placediscovery.algorithms.PlaceDiscoveryAlgorithmFactory;
-import org.processmining.placebasedlpmdiscovery.prom.placediscovery.parameters.EstMinerPlaceDiscoveryParameters;
-import org.processmining.placebasedlpmdiscovery.prom.placediscovery.parameters.SPECppPlaceDiscoveryParameters;
 
 import java.util.Set;
 
+/**
+ * A provider of places for LPM discovery. Implementations can provide places from various sources,
+ * such as files, sets, or by discovering them from an event log.
+ */
 public interface PlacesProvider {
 
-    static PlacesProvider getInstance() {
-        return specpp();
-    }
-
-    static PlacesProvider est() {
-        PlaceDiscoveryAlgorithmFactory factory = new PlaceDiscoveryAlgorithmFactory();
-        EstMinerPlaceDiscoveryParameters parameters = new EstMinerPlaceDiscoveryParameters();
-        return new DiscoveryPlacesProvider(parameters.getAlgorithm(factory));
-    }
-
-    static PlacesProvider specpp() {
-        PlaceDiscoveryAlgorithmFactory factory = new PlaceDiscoveryAlgorithmFactory();
-        SPECppPlaceDiscoveryParameters parameters = new SPECppPlaceDiscoveryParameters();
-        return new DiscoveryPlacesProvider(parameters.getAlgorithm(factory));
-    }
-
+    /**
+     * Creates a PlacesProvider that reads places from a file.
+     * @param fileName the name of the file to read places from
+     * @return a PlacesProvider that reads places from the specified file
+     */
     static PlacesProvider fromFile(String fileName) {
         return new FromFilePlacesProvider(fileName);
     }
 
+    /**
+     * Creates a PlacesProvider that provides the given set of places.
+     * @param places the set of places to provide
+     * @return a PlacesProvider that provides the given set of places
+     */
     static PlacesProvider fromSet(Set<Place> places) {
-        return log -> places;
+        return () -> places;
+    }
+
+    /**
+     * Creates a PlacesProvider that provides the given set of places by discovering them in the event log.
+     * @param log the XLog to discover places from
+     * @return a PlacesProvider that discovers places from the given log
+     */
+    static PlacesProvider fromLog(XLog log) {
+        return FromLogPlacesProvider.recommended(log);
     }
 
-    Set<Place> from(XLog log);
+    /**
+     * Provides a set of places.
+     * @return a set of places
+     */
+    Set<Place> provide();
 }

src/org/processmining/placebasedlpmdiscovery/prom/PlacesProvider.java

@@ -0,0 +1,8 @@
+package org.processmining.placebasedlpmdiscovery.prom;
+
+import org.deckfour.xes.model.XLog;
+
+public interface PlacesProviderFactory {
+
+    PlacesProvider create(XLog log);
+}

src/org/processmining/placebasedlpmdiscovery/prom/PlacesProviderFactory.java

@@ -4,7 +4,6 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.processmining.placebasedlpmdiscovery.lpmdiscovery.LPMDiscovery;
-import org.processmining.placebasedlpmdiscovery.lpmdiscovery.PlaceBasedLPMDiscovery;
 import org.processmining.placebasedlpmdiscovery.model.LocalProcessModel;
 import org.processmining.placebasedlpmdiscovery.model.Place;
 import org.processmining.placebasedlpmdiscovery.model.discovery.LPMDiscoveryResult;
@@ -37,7 +36,7 @@ public static void setup() {
     @Test
     public void givenDefault_whenFrom_thenLPMsAbAc() {
         // given
-        LPMDiscovery lpmDiscovery = new PlaceBasedLPMDiscovery(placesProvider);
+        LPMDiscovery lpmDiscovery = LPMDiscovery.placeBased(placesProvider);
 
         // when
         LPMDiscoveryResult result = lpmDiscovery.from(eventLog);
@@ -52,7 +51,7 @@ public void givenDefault_whenFrom_thenLPMsAbAc() {
     @Test
     public void givenDefaultWithPlaceLimit_whenFrom_thenLPMsEmpty() {
         // given
-        LPMDiscovery lpmDiscovery = new PlaceBasedLPMDiscovery(placesProvider, 1);
+        LPMDiscovery lpmDiscovery = LPMDiscovery.placeBased(placesProvider, 1);
 
         // when
         LPMDiscoveryResult result = lpmDiscovery.from(eventLog);