/* * public HashMap getLeafElements() { HashMap map = new HashMap(); Object[] * elts = dataElements.values().toArray(); for (int j=0; j<elts.length; j++) * { PDMDataElement data = (PDMDataElement) elts[j]; * map.put(data.getID(),data); } Object[] ops = * operations.values().toArray(); for (int i=0; i<ops.length; i++){ * PDMOperation op = (PDMOperation) ops[i]; if * (!(op.getInputElements().isEmpty())){ HashMap outs = * op.getOutputElements(); Object[] outArray = outs.values().toArray(); for * (int j=0; j<outArray.length; j++) { PDMDataElement d = (PDMDataElement) * outArray[j]; map.remove(d.getID()); } } } return map; } */ public HashMap getLeafElements() { HashMap result = new HashMap(); HashSet leafOps = getLeafOperations(); if (!(leafOps.isEmpty())) { Iterator it = leafOps.iterator(); while (it.hasNext()) { PDMOperation op = (PDMOperation) it.next(); PDMDataElement data = op.getOutputElement(); result.put(data.getID(), data); } } else { Object[] elts = dataElements.values().toArray(); for (int j = 0; j < elts.length; j++) { PDMDataElement data = (PDMDataElement) elts[j]; result.put(data.getID(), data); } Object[] ops = operations.values().toArray(); for (int i = 0; i < ops.length; i++) { PDMOperation op = (PDMOperation) ops[i]; HashMap outs = op.getOutputElements(); Object[] outArray = outs.values().toArray(); for (int j = 0; j < outArray.length; j++) { PDMDataElement d = (PDMDataElement) outArray[j]; result.remove(d.getID()); } } } return result; }
public PDMState checkIfStateExists( PDMStateSpace statespace, HashSet data, HashSet exec, HashSet failed) { PDMState result = null; boolean bool = false; HashSet states = statespace.getStates(); Iterator it = states.iterator(); while (it.hasNext() && !bool) { PDMState state2 = (PDMState) it.next(); boolean one = false; boolean two = false; boolean three = false; HashSet data2 = state2.dataElements; HashSet exec2 = state2.executedOperations; HashSet failed2 = state2.failedOperations; one = hashSetContainsSameDataElements(data, data2); two = hashSetContainsSameOperations(exec, exec2); three = hashSetContainsSameOperations(failed, failed2); if (one && two && three) { bool = true; result = state2; } } return result; }
/** * Get the outputable nodes of the circuit * * @return an hashset of the outputable nodes of the circuit */ public HashSet<Outputable> getOutputables() { HashSet<Outputable> outputs = new HashSet<Outputable>(); for (iterNodes = getNodesIterator(); iterNodes.hasNext(); ) { Node n = iterNodes.next(); if (n.getCategoryID() == Node.OUTPUT) outputs.add((Outputable) n); } return outputs; }
/** * Get the inputable nodes of the circuit * * @return an hashset of the inputable nodes of the circuit */ public HashSet<Inputable> getInputables() { HashSet<Inputable> inputs = new HashSet<Inputable>(); for (iterNodes = getNodesIterator(); iterNodes.hasNext(); ) { Node n = iterNodes.next(); if (n.getCategoryID() == Node.INPUT) inputs.add((Inputable) n); } return inputs; }
public HashSet getLeafOperations() { HashSet result = new HashSet(); Object[] ops = operations.values().toArray(); for (int i = 0; i < ops.length; i++) { PDMOperation op = (PDMOperation) ops[i]; if ((op.getInputElements().isEmpty())) { result.add(op); } } return result; }
/** * Returns a HashSet with the operations that have data element 'data' as output element. * * @param data PDMDataElement * @return HashSet */ public HashSet getOperationsWithOutputElement(PDMDataElement data) { HashSet opso = new HashSet(); Object[] ops = operations.values().toArray(); for (int i = 0; i < ops.length; i++) { PDMOperation op = (PDMOperation) ops[i]; HashMap outputs = op.getOutputElements(); if (outputs.containsValue(data)) { opso.add(op); } } return opso; }
public static PetriNet convert(ConfigurableEPC baseEPC) { HashMap<EPCFunction, Transition> functionActivityMapping; HashMap<EPCConnector, Place> xorconnectorChoiceMapping; // HV: Initialize the mappings. functionActivityMapping = new HashMap<EPCFunction, Transition>(); xorconnectorChoiceMapping = new HashMap<EPCConnector, Place>(); // Check to use the weights if necessary // HV: Add both mappings. On completion, these will be filledd. PetriNet petrinet = EPCToPetriNetConverter.convert( baseEPC, new HashMap(), functionActivityMapping, xorconnectorChoiceMapping); HashSet visible = new HashSet(); // HV: The next block is taken care of by the functionActivityMapping // below. /* * Iterator it = petrinet.getTransitions().iterator(); while * (it.hasNext()) { Transition t = (Transition) it.next(); if (t.object * instanceof EPCFunction) { // if (t.getLogEvent() != null) { // Add * transitions with LogEvent (i.e. referring to functions) * visible.add(t); } } */ // HV: Prevent the places mapped onto from being reduced. visible.addAll(functionActivityMapping.values()); visible.addAll(xorconnectorChoiceMapping.values()); Message.add(visible.toString(), Message.DEBUG); Iterator it = petrinet.getPlaces().iterator(); while (it.hasNext()) { Place p = (Place) it.next(); if (p.inDegree() * p.outDegree() == 0) { // Add Initial and final places to visible, i.e. places that // refer to in and output events visible.add(p); } } // Reduce the PetriNet with Murata rules, while keeping the visible ones PetriNetReduction pnred = new PetriNetReduction(); pnred.setNonReducableNodes(visible); HashMap pnMap = new HashMap(); // Used to map pre-reduction nodes to // post-reduction nodes. PetriNet reduced = pnred.reduce(petrinet, pnMap); if (reduced != petrinet) { // Update both mappings from pre-reduction nodes to post-reduction // nodes. HashMap<EPCFunction, Transition> newFunctionActivityMapping = new HashMap<EPCFunction, Transition>(); for (EPCFunction function : functionActivityMapping.keySet()) { Transition transition = (Transition) functionActivityMapping.get(function); if (pnMap.keySet().contains(transition)) { newFunctionActivityMapping.put(function, (Transition) pnMap.get(transition)); } } functionActivityMapping = newFunctionActivityMapping; HashMap<EPCConnector, Place> newXorconnectorChoiceMapping = new HashMap<EPCConnector, Place>(); for (EPCConnector connector : xorconnectorChoiceMapping.keySet()) { Place place = (Place) xorconnectorChoiceMapping.get(connector); if (pnMap.keySet().contains(place)) { newXorconnectorChoiceMapping.put(connector, (Place) pnMap.get(place)); } } xorconnectorChoiceMapping = newXorconnectorChoiceMapping; } reduced.makeClusters(); // filter the \nunknown:normal ArrayList<Transition> alTrans = reduced.getVisibleTasks(); for (int i = 0; i < alTrans.size(); i++) { Transition t = alTrans.get(i); String id = t.getIdentifier(); int idx = id.indexOf("\\nunknown:normal"); if (idx > 0) { id = id.substring(0, idx); } // �˴������ֵ��ѯ�滻���е�label String mappedId = htDict.get(id); if (mappedId != null) { t.setIdentifier(mappedId); } else { t.setIdentifier(id); } } return reduced; }
@Override public HashSet<ScoredAnnotation> solveSa2W(String text) throws AnnotationException { HashSet<ScoredAnnotation> res; try { res = new HashSet<ScoredAnnotation>(); lastTime = Calendar.getInstance().getTimeInMillis(); URL wikiApi = new URL(url); String parameters = "references=true&repeatMode=all&minProbability=0.0&source=" + URLEncoder.encode(text, "UTF-8"); HttpURLConnection slConnection = (HttpURLConnection) wikiApi.openConnection(); slConnection.setRequestProperty("accept", "text/xml"); slConnection.setDoOutput(true); slConnection.setDoInput(true); slConnection.setRequestMethod("POST"); slConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); slConnection.setRequestProperty("charset", "utf-8"); slConnection.setRequestProperty( "Content-Length", "" + Integer.toString(parameters.getBytes().length)); slConnection.setUseCaches(false); DataOutputStream wr = new DataOutputStream(slConnection.getOutputStream()); wr.writeBytes(parameters); wr.flush(); wr.close(); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(slConnection.getInputStream()); /* URL wikiApi = new URL(url+"?references=true&repeatMode=all&minProbability=0.0&source="+URLEncoder.encode(text, "UTF-8")); URLConnection wikiConnection = wikiApi.openConnection(); DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(wikiConnection.getInputStream()); */ lastTime = Calendar.getInstance().getTimeInMillis() - lastTime; XPathFactory xPathfactory = XPathFactory.newInstance(); XPath xpath = xPathfactory.newXPath(); XPathExpression idExpr = xpath.compile("//detectedTopic/@id"); XPathExpression weightExpr = xpath.compile("//detectedTopic/@weight"); XPathExpression referenceExpr = xpath.compile("//detectedTopic/references"); NodeList ids = (NodeList) idExpr.evaluate(doc, XPathConstants.NODESET); NodeList weights = (NodeList) weightExpr.evaluate(doc, XPathConstants.NODESET); NodeList references = (NodeList) referenceExpr.evaluate(doc, XPathConstants.NODESET); for (int i = 0; i < weights.getLength(); i++) { if (weights.item(i).getNodeType() != Node.TEXT_NODE) { int id = Integer.parseInt(ids.item(i).getNodeValue()); float weight = Float.parseFloat(weights.item(i).getNodeValue()); // System.out.println("ID="+ids.item(i).getNodeValue()+" weight="+weight); XPathExpression startExpr = xpath.compile("//detectedTopic[@id=" + id + "]/references/reference/@start"); XPathExpression endExpr = xpath.compile("//detectedTopic[@id=" + id + "]/references/reference/@end"); NodeList starts = (NodeList) startExpr.evaluate(references.item(i), XPathConstants.NODESET); NodeList ends = (NodeList) endExpr.evaluate(references.item(i), XPathConstants.NODESET); for (int j = 0; j < starts.getLength(); j++) { int start = Integer.parseInt(starts.item(j).getNodeValue()); int end = Integer.parseInt(ends.item(j).getNodeValue()); int len = end - start; res.add(new ScoredAnnotation(start, len, id, weight)); } } } } catch (Exception e) { e.printStackTrace(); throw new AnnotationException( "An error occurred while querying Wikipedia Miner API. Message: " + e.getMessage()); } return res; }
/** * Export PDM model to Declare process model. * * @param bw Writer * @throws IOException If writing fails */ public void writePDMToDeclare(Writer bw) throws IOException { // write the preamble of the XML file bw.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"); bw.write("<model>\n"); bw.write("<assignment language=\"ConDec\" name=\"" + name + "\">\n"); // write the activity definitions, i.e. each operation in the PDM is an // activity definition in Declare bw.write("<activitydefinitions>\n"); // start with an initial activity that puts the values for the leaf // elements of the PDM bw.write("<activity id=\"Initial\" name=\"Initial\">\n"); bw.write("<authorization/>\n"); bw.write("<datamodel>\n"); // all leaf elements HashMap leafs = getLeafElements(); Object[] leafElts = leafs.values().toArray(); for (int i = 0; i < leafElts.length; i++) { PDMDataElement data = (PDMDataElement) leafElts[i]; data.writePDMToDeclare(bw, "output"); } bw.write("</datamodel>\n"); bw.write("<attributes/>\n"); bw.write("</activity>\n"); // first remove input operations from the set of operations and then // write all real operations HashMap realOps = (HashMap) operations.clone(); HashSet inputOps = getLeafOperations(); Iterator it7 = inputOps.iterator(); while (it7.hasNext()) { PDMOperation op = (PDMOperation) it7.next(); realOps.remove(op.getID()); } Iterator it4 = realOps.values().iterator(); while (it4.hasNext()) { PDMOperation operation = (PDMOperation) it4.next(); operation.writePDMToDeclare(bw); } bw.write("\n"); // write all input operations (i.e. producing input data elements) Iterator it8 = inputOps.iterator(); while (it8.hasNext()) { PDMOperation op = (PDMOperation) it8.next(); op.writePDMToDeclare(bw); } bw.write("</activitydefinitions>\n"); // write the constraint definition, for now we do not have any // constraints in the PDM that are translated to Declare bw.write("<constraintdefinitions>\n"); bw.write("</constraintdefinitions>\n"); // write all dataelements bw.write("<data>\n"); Iterator it5 = dataElements.values().iterator(); while (it5.hasNext()) { PDMDataElement dataElement = (PDMDataElement) it5.next(); dataElement.writePDMToDeclare(bw); } bw.write("</data>\n"); // write the organizational information bw.write("<team/>\n"); // TODO: improve graphical positioning of activities. Now they are // presented in one long line. // write the graphical positioning information of the Declare model, // first the initial operation, then the real operations and then the // input operations. bw.write("<graphical>\n"); bw.write("<cells>\n"); Iterator it6 = realOps.values().iterator(); Double pos = 10.0; while (it6.hasNext()) { PDMOperation operation = (PDMOperation) it6.next(); bw.write( "<cell activitydefinition=\"" + operation.getOperationNR() + "\" height=\"40.0\" width=\"80.0\" x=\"" + pos + "\" y=\"90.0\" />\n"); pos = pos + 85.0; } Iterator it9 = inputOps.iterator(); pos = 10.0; while (it9.hasNext()) { PDMOperation operation = (PDMOperation) it9.next(); bw.write( "<cell activitydefinition=\"" + operation.getOperationNR() + "\" height=\"40.0\" width=\"80.0\" x=\"" + pos + "\" y=\"180.0\" />\n"); pos = pos + 85.0; } bw.write("</cells>\n"); // write the connectors bw.write("<connectors/>\n"); // close the XML file in the right way bw.write("</graphical>\n"); bw.write("</assignment>\n"); bw.write("</model>\n"); }
public boolean hashSetContainsSameOperations(HashSet set1, HashSet set2) { boolean result = false; HashSet s1 = (HashSet) set1.clone(); HashSet s2 = (HashSet) set2.clone(); // first part, are all elements of s1 also in s2? boolean one = false; Iterator it = set1.iterator(); while (it.hasNext()) { PDMOperation d = (PDMOperation) it.next(); if (s2.contains(d)) { s1.remove(d); } } if (s1.isEmpty()) { one = true; } // second part, are all elements of s21 also in s1? boolean two = false; HashSet s3 = (HashSet) set1.clone(); HashSet s4 = (HashSet) set2.clone(); Iterator it2 = set2.iterator(); while (it2.hasNext()) { PDMOperation d = (PDMOperation) it2.next(); if (s3.contains(d)) { s4.remove(d); } } if (s4.isEmpty()) { two = true; } // administrative stuff s1.clear(); s2.clear(); s3.clear(); s4.clear(); result = one && two; return result; }
public HashSet calculateNextStates( PDMState state, PDMStateSpace statespace, boolean root, boolean failure, int numStates, int breadth) { HashSet result = new HashSet(); HashSet data = state.dataElements; HashSet exec1 = state.executedOperations; HashSet failed = state.failedOperations; HashSet execOps = calculateExecutableOperations(data, exec1, failed, root); Iterator it = execOps.iterator(); int b = 0; int bLimit = 0; if (!failure) { bLimit = breadth; } else { bLimit = breadth / 2; } // for each executable operation a new state is created while (it.hasNext() && i < numStates && b < bLimit) { if (!failure) { PDMOperation op = (PDMOperation) it.next(); PDMDataElement d = op.getOutputElement(); // First, add the state with the operation 'op' succesfully // executed HashSet ins2 = (HashSet) data.clone(); // NB: is it necessary to // clear this clone // again? ins2.add(d); HashSet exec2 = (HashSet) exec1.clone(); exec2.add(op); PDMState s = checkIfStateExists(statespace, ins2, exec2, failed); // Check whether the new state already exists // If so, then another link to this state is made if (!(s == null)) { PDMState st = s; PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), 1.0); statespace.addEdge(edge); } // If not, a new state is created and linked to the current // state else { String name = "state" + i; // int num = checkStatusOfState(statespace, ) PDMState st = new PDMState(statespace, name, ins2, exec2, failed); statespace.addState(st); result.add(st); PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), 1.0); statespace.addEdge(edge); i++; b++; } } // Then, if failure of operations is considered, add the state with // the failed operations 'op'. if (failure) { PDMOperation op = (PDMOperation) it.next(); PDMDataElement d = op.getOutputElement(); // First, add the state with the operation 'op' succesfully // executed HashSet ins2 = (HashSet) data.clone(); // NB: is it necessary to // clear this clone // again? ins2.add(d); HashSet exec2 = (HashSet) exec1.clone(); exec2.add(op); PDMState s = checkIfStateExists(statespace, ins2, exec2, failed); // Check whether the new state already exists // If so, then another link to this state is made if (!(s == null)) { PDMState st = s; double prob = 1.0 - (op.getFailureProbability()); PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), prob); statespace.addEdge(edge); } // If not, a new state is created and linked to the current // state else { String name = "state" + i; // int num = checkStatusOfState(statespace, ) PDMState st = new PDMState(statespace, name, ins2, exec2, failed); statespace.addState(st); result.add(st); double prob = 1.0 - (op.getFailureProbability()); PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), prob); statespace.addEdge(edge); i++; b++; } HashSet failed2 = (HashSet) failed.clone(); failed2.add(op); PDMState s2 = checkIfStateExists(statespace, data, exec1, failed2); if (!(s2 == null)) { PDMState st = s2; PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), op.getFailureProbability()); statespace.addEdge(edge); } // If not, a new state is created and linked to the current // state else { String name = "state" + i; PDMState st = new PDMState(statespace, name, data, exec1, failed2); statespace.addState(st); result.add(st); PDMStateEdge edge = new PDMStateEdge(state, st, op.getID(), op.getFailureProbability()); statespace.addEdge(edge); i++; b++; } // failed2.clear(); } } return result; }
public PDMStateSpace calculateSimpleStateSpace( boolean root, boolean failure, boolean input, boolean colored, int numStates, int breadth) { PDMStateSpace result = new PDMStateSpace(this, colored); HashSet states = new HashSet(); int j = (operations.size() + 1); if (!input) { HashSet empty = new HashSet(); PDMState st = new PDMState(result, "state" + i, empty, empty, empty); result.addState(st); states.add(st); i++; } else { // Start with the complete set of input data elements available HashSet empty = new HashSet(); String name = new String("state" + i); HashSet ins = new HashSet(); // this hashSet contains the input // elements to the process (input // elements of PDM) HashSet execOps = new HashSet(); // Fill the hashSet with the leaf elements HashMap leafs = getLeafElements(); Object[] leafElts = leafs.values().toArray(); for (int i = 0; i < leafElts.length; i++) { PDMDataElement d = (PDMDataElement) leafElts[i]; ins.add(d); } HashSet leafOps = getLeafOperations(); Iterator it = leafOps.iterator(); while (it.hasNext()) { PDMOperation op = (PDMOperation) it.next(); execOps.add(op); } PDMState start = new PDMState(result, name, ins, execOps, empty); // start // state // of // the // statespace result.addState(start); i++; states.add(start); } while (!states.isEmpty()) { HashSet states2 = (HashSet) states.clone(); Iterator it = states2.iterator(); while (it.hasNext()) { PDMState state = (PDMState) it.next(); HashSet nextStates = calculateNextStates(state, result, root, failure, numStates, breadth); Iterator it2 = nextStates.iterator(); // Add the new states to iterator while (it2.hasNext()) { PDMState st = (PDMState) it2.next(); states.add(st); } states.remove(state); } } i = 0; j = 0; Message.add("<PDMMDPStateSpace>", Message.TEST); Message.add("<NumberOfStates = " + result.getNumberOfStates() + " >", Message.TEST); Message.add("</PDMMDPStateSpace>", Message.TEST); return result; }
public HashSet calculateExecutableOperations( HashSet dataElts, HashSet executed, HashSet failed, boolean root) { HashSet result = new HashSet(); HashSet enabledOperations = new HashSet(); if (root) { // Calculate the enabled operations (i.e. those operation of which // all input elements are in the set of available elements) Object[] ops = operations.values().toArray(); for (int i = 0; i < ops.length; i++) { PDMOperation op = (PDMOperation) ops[i]; HashMap inputs = op.getInputElements(); Object[] ins = inputs.values().toArray(); boolean enabled = true; int k = 0; while (enabled && k < ins.length) { PDMDataElement d = (PDMDataElement) ins[k]; if (!(dataElts.contains(d))) { enabled = false; } k++; } if (enabled) { enabledOperations.add(op); // System.out.println("Enabled operation: "+ op.getID()); } } } else if (!(dataElts.contains(this.getRootElement()))) { // Calculate the enabled operations (i.e. those operation of which // all input elements are in the set of available elements) Object[] ops = operations.values().toArray(); for (int i = 0; i < ops.length; i++) { PDMOperation op = (PDMOperation) ops[i]; HashMap inputs = op.getInputElements(); Object[] ins = inputs.values().toArray(); boolean enabled = true; int k = 0; while (enabled && k < ins.length) { PDMDataElement d = (PDMDataElement) ins[k]; if (!(dataElts.contains(d))) { enabled = false; } k++; } if (enabled) { enabledOperations.add(op); } } } // remove already executed operations Iterator exIt = executed.iterator(); while (exIt.hasNext()) { PDMOperation op = (PDMOperation) exIt.next(); enabledOperations.remove(op); } // remove already failed operations Iterator fIt = failed.iterator(); while (fIt.hasNext()) { PDMOperation op = (PDMOperation) fIt.next(); enabledOperations.remove(op); } result = enabledOperations; return result; }