/** * Removes one token from the marked output places (subsets) of the tasks in <i>tasks</i> that * contain <i>element</i>. * * @param element element to fire * @param tasks whose output places point to element */ private void removeTokensOutputPlaces(int element, HNSubSet tasks) { HNSubSet subset = null; HNSet subsets = null; Integer tokens = null; int taskToFire; int task; // Checking if element is a start element if (hNet.getInputSet(element).size() == 0) { if (startPlace > 0) { startPlace--; numberTokens--; } } else { taskToFire = element; for (int iTasks = 0; iTasks < tasks.size(); iTasks++) { task = tasks.get(iTasks); subsets = auxMapping.getRelatedSubsets(taskToFire, task); if (subsets != null) { for (int iSubsets = 0; iSubsets < subsets.size(); iSubsets++) { subset = subsets.get(iSubsets); tokens = getNumberTokens(task, subset); if (tokens.intValue() > 0) { decreaseNumberTokens(task, subset); numberTokens--; } } } } } }
private HNSet getAlreadyMarkedPlaces(HNSet set, int task) { HNSet markedPlaces = null; HNSubSet subset = null; markedPlaces = new HNSet(); for (int iSet = 0; iSet < set.size(); iSet++) { subset = set.get(iSet); if (subset.contains(task)) { markedPlaces.add(subset); } } return markedPlaces; }
/** Returns the current enabled elements at the current marking. */ public HNSubSet getCurrentEnabledElements() { int element = -1; HNSubSet disabledElements = null; disabledElements = new HNSubSet(); for (int iPossiblyEnabledElements = 0; iPossiblyEnabledElements < possiblyEnabledElements.size(); iPossiblyEnabledElements++) { element = possiblyEnabledElements.get(iPossiblyEnabledElements); if (!isEnabled(element)) { disabledElements.add(element); } } possiblyEnabledElements.removeAll(disabledElements); return possiblyEnabledElements; }
private void buildMapping(HeuristicsNet hn) { HNSet outputSubsets; HNSubSet outputSubset; int taskInSubset; mapping = new HNSet[hn.size()][hn.size()]; for (int task = 0; task < hn.size(); task++) { outputSubsets = hn.getOutputSet(task); for (int iOutputSubsets = 0; iOutputSubsets < outputSubsets.size(); iOutputSubsets++) { // inserting for every element outputSubset = outputSubsets.get(iOutputSubsets); for (int iSubset = 0; iSubset < outputSubset.size(); iSubset++) { taskInSubset = outputSubset.get(iSubset); insertInMapping(taskInSubset, task, outputSubset); } } } }
private HNSubSet getTasksWithEmptyOutputPlaces(int task) { HNSubSet tasksEmptyOutPlaces; HNSubSet inputTasks; int inputTask; HNSet outputSubsets; inputTasks = hNet.getAllElementsInputSet(task); tasksEmptyOutPlaces = new HNSubSet(); for (int iInputTasks = 0; iInputTasks < inputTasks.size(); iInputTasks++) { inputTask = inputTasks.get(iInputTasks); outputSubsets = auxMapping.getRelatedSubsets(task, inputTask); if (outputSubsets != null) { if (!allSubsetsAreMarked(inputTask, outputSubsets)) { tasksEmptyOutPlaces.add(inputTask); } } else { tasksEmptyOutPlaces.add(inputTask); } } return tasksEmptyOutPlaces; }
private HNSubSet getAllOutputElementsOfDuplicates(HNSubSet duplicates) { // Returns the union set of the output tasks of the tasks in // "duplicates". // The returned union set has already the codes mapped to the ATEs in // the log! HNSubSet union = new HNSubSet(); HNSubSet allElements; for (int i = 0; i < duplicates.size(); i++) { allElements = hNet.getAllElementsOutputSet(duplicates.get(i)); for (int j = 0; j < allElements.size(); j++) { union.add(hNet.getDuplicatesMapping()[allElements.get(j)]); } } return union; }
/** Sets the marking to the initial marking. */ public void reset() { Iterator outElements = null; HNSubSet outSubset = null; numberTokens = 1; // in the source place startPlace = 1; endPlace = 0; // initially, only the single start tasks is enabled possiblyEnabledElements = new HNSubSet(); for (int i = 0; i < hNet.getStartTasks().size(); i++) { possiblyEnabledElements.add(hNet.getStartTasks().get(i)); } for (int i = 0; i < size; i++) { outElements = marking[i].keySet().iterator(); while (outElements.hasNext()) { outSubset = (HNSubSet) outElements.next(); marking[i].put(outSubset, new Integer(0)); } outElements = null; } }
private CombinationTasksToFire findBestCombination( CombinationTasksToFire bCombination, HNSet inputSet, int rootTask, CombinationTasksToFire combination, HNSubSet treatedTasks) { int task = -1; HNSet alreadyMarkedPlaces = null; HNSet temp_inputSet = null; HNSubSet noTokensFromTasks = null; HNSubSet subset = null; if ((bCombination.getTasks().size() == 0) || (bCombination.getNumberMissingTokens() > combination.getNumberMissingTokens())) { if (rootTask != ROOT_TASK_ID) { alreadyMarkedPlaces = getAlreadyMarkedPlaces(inputSet, rootTask); noTokensFromTasks = HNSet.getUnionSet(alreadyMarkedPlaces); inputSet.removeAll(alreadyMarkedPlaces); combination.getTasks().add(rootTask); } if (inputSet.size() == 0) { bCombination = combination.copy(); } else { // akam: I stoppe here - 10/07/2005 if (rootTask != ROOT_TASK_ID) { temp_inputSet = new HNSet(); for (int iInputSet = 0; iInputSet < inputSet.size(); iInputSet++) { subset = inputSet.get(iInputSet); subset.removeAll(noTokensFromTasks); subset.removeAll(treatedTasks); if (subset.size() == 0) { combination.setTokens(combination.getNumberMissingTokens() + 1); } else { temp_inputSet.add(subset); } } inputSet = temp_inputSet; } for (int iInputSet = 0; iInputSet < inputSet.size(); iInputSet++) { subset = inputSet.get(iInputSet); while (subset.size() > 0) { task = subset.get(generator.nextInt(subset.size())); bCombination = findBestCombination( bCombination, inputSet.deepCopy(), task, combination.copy(), treatedTasks.deepCopy()); treatedTasks.add(task); subset.remove(task); } } } } return bCombination; }
private CombinationTasksToFire findBestSetTasks(int element) { CombinationTasksToFire bCombination = null; CombinationTasksToFire combination = null; HNSubSet noTokensFromTasks = null; HNSubSet treatedTasks = null; HNSet inputSet = null; HNSet temp_inputSet = null; HNSubSet subset = null; int numberMissingTokens = 0; int rootTask = ROOT_TASK_ID; bCombination = new CombinationTasksToFire(); inputSet = hNet.getInputSet(element); if (inputSet.size() == 0) { if (startPlace <= 0) { numberMissingTokens++; // one token is missing } } else { // inputSubset is not empty. Search for tasks that "have tokens" to // element noTokensFromTasks = getTasksWithEmptyOutputPlaces(element); // >>>>>>>>>>>>>>>>>> Hint!!! I think that's why I don't run into // problems... // /// Idea -> shrink the subsets without using a temp variable, get // / the size before shrinking, shrink them, reorder the set and // /remove the empty set (do this via a method in the class // /HNSet, get the new size. This is the number of missing tokens. // make a copy to avoid destroying the original net inputSet = inputSet.deepCopy(); temp_inputSet = new HNSet(); // removing the tasks whose output subsets that contain element are // empty for (int iInputSubsets = 0; iInputSubsets < inputSet.size(); iInputSubsets++) { subset = inputSet.get(iInputSubsets); subset.removeAll(noTokensFromTasks); if (subset.size() == 0) { numberMissingTokens += 1; } else { temp_inputSet.add(subset); } } inputSet = temp_inputSet; // retrieving the best combination of tasks that can fire to enable // element if (inputSet.size() > 0) { combination = new CombinationTasksToFire(); treatedTasks = new HNSubSet(); bCombination = findBestCombination(bCombination, inputSet, rootTask, combination, treatedTasks); } } bCombination.setElementToFire(element); bCombination.setTokens(bCombination.getNumberMissingTokens() + numberMissingTokens); return bCombination; }
private void addToPossiblyEnabledElements(int element) { HNSubSet subset = hNet.getAllElementsOutputSet(element); for (int i = 0; i < subset.size(); i++) { possiblyEnabledElements.add(subset.get(i)); } }
private int identifyDuplicateToFire(HNSubSet duplicates, int elementInATE) { HNSubSet candidateDuplicates = new HNSubSet(); HNSubSet allElements; for (int i = 0; i < duplicates.size(); i++) { allElements = hNet.getAllElementsOutputSet(duplicates.get(i)); for (int j = 0; j < allElements.size(); j++) { if (elementInATE == hNet.getDuplicatesMapping()[allElements.get(j)]) { candidateDuplicates.add(duplicates.get(i)); break; } } } if (candidateDuplicates.size() <= 0) { candidateDuplicates = duplicates; // we can choose any of the tasks // because none has // followers in the process instance... } return candidateDuplicates.get(generator.nextInt(candidateDuplicates.size())); }
/** * Fires a element even if it is not enabled. When the element has duplicates, it looks ahead to * set which duplicate to fire. * * <p><b>Note:</b> The element MUST be in the net. * * @param element element to be fired. * @param pi process instance where the element to be fired is. * @param elementPositionInPi element position. * @return int number of tokens that needed to be added to fire this element. */ public int fire(int element, ProcessInstance pi, int elementPositionInPi) { int addedTokens = 0; int elementDuplicates; if ((hNet.getReverseDuplicatesMapping()[element]).size() == 1) { elementDuplicates = hNet.getReverseDuplicatesMapping()[element].get(0); } else { // identify which duplicate to fire HNSubSet duplicates = hNet.getReverseDuplicatesMapping()[element].deepCopy(); // getting the duplicates that are enabled for (int i = 0; i < duplicates.size(); i++) { if (!isEnabled(duplicates.get(i))) { duplicates.remove(duplicates.get(i)); } } if (duplicates.size() > 0) { if (duplicates.size() == 1) { elementDuplicates = duplicates.get(0); } else { // getting the output tasks of the duplicates. These output // are used to // look ahead at the process instance HNSubSet unionMappedToATEsCode = getAllOutputElementsOfDuplicates(duplicates); AuditTrailEntryList ATEntriesList = pi.getAuditTrailEntryList(); // advancing the pointer in the ATEntries till the current // element + 1 AuditTrailEntry ATEntry; int elementInATE = -1; for (int i = elementPositionInPi + 1; i < ATEntriesList.size(); i++) { try { ATEntry = ATEntriesList.get(i); elementInATE = this.hNet .getLogEvents() .findLogEventNumber(ATEntry.getElement(), ATEntry.getType()); if (unionMappedToATEsCode.contains(elementInATE)) { break; } } catch (IOException ex) { break; } catch (IndexOutOfBoundsException ex) { break; } } elementDuplicates = identifyDuplicateToFire(duplicates, elementInATE); } } else { // because no duplicate is enabled, a random one is chosen to // fire... elementDuplicates = (hNet.getReverseDuplicatesMapping()[element]) .get(generator.nextInt(hNet.getReverseDuplicatesMapping()[element].size())); } } bestCombination = findBestSetTasks(elementDuplicates); addedTokens += bestCombination.getNumberMissingTokens(); removeTokensOutputPlaces(elementDuplicates, bestCombination.getTasks()); addTokensOutputPlaces(elementDuplicates); addToPossiblyEnabledElements(elementDuplicates); // registering the firing of element... hNet.increaseElementActualFiring( elementDuplicates, MethodsForWorkflowLogDataStructures.getNumberSimilarProcessInstances(pi)); // updating the arc usage for the individual... hNet.increaseArcUsage( bestCombination.getElementToFire(), bestCombination.getTasks(), MethodsForWorkflowLogDataStructures.getNumberSimilarProcessInstances(pi)); return addedTokens; }