/** * Gets all the objects of provided BioPAX types. * * @param model BioPAX (PaxTools) model * @param classes query BioPAX types - e.g. Protein.class, Complex.class * @return */ public static Set<? extends BioPAXElement> getObjects(Model model, Class<? extends BioPAXElement>... classes) { Set<BioPAXElement> coll = new HashSet<BioPAXElement>(); if (model != null) { for (Class<? extends BioPAXElement> c : classes) { coll.addAll(model.getObjects(c)); } } return coll; }
private Map<BioPAXElement, Group> inferGroups(Model model, Grouper grouper) { ersToBeGrouped = new HashSet<EntityReference>(model.getObjects(EntityReference.class)); complexesToBeGrouped = new HashSet<Complex>(model.getObjects(Complex.class)); for (EntityReference er : ersToBeGrouped) { addIfNotNull(er, inferGroupFromER(er, model)); } for (Complex complex : complexesToBeGrouped) { addIfNotNull(complex, inferGroupFromComplex(complex, model)); } return element2GroupMap; }
private void fixXrefs(Model model, Map<String, String> mappings) { final Set<Xref> xrefs = model.getObjects(Xref.class); for (Xref xref : xrefs) { if (mappings.containsKey(xref.getDb())) { xref.setDb(mappings.get(xref.getDb())); } } }
private void createComplexEdges(CyNetwork network) { // iterate through all pe's for (Complex complexElement : model.getObjects(Complex.class)) { Set<PhysicalEntity> members = complexElement.getComponent(); if(members.isEmpty()) continue; // get node CyNode complexCyNode = bpeToCyNodeMap.get(complexElement); // get all components. There can be 0 or more for (PhysicalEntity member : members) { CyNode complexMemberCyNode = bpeToCyNodeMap.get(member); // create edge, set attributes CyEdge edge = network.addEdge(complexCyNode, complexMemberCyNode, true); AttributeUtil.set(network, edge, "interaction", "contains", String.class); } } }
public void check(final Validation validation, Model model) { Cluster<BioPAXElement> algorithm = new Cluster<BioPAXElement>() { @Override public boolean match(BioPAXElement a, BioPAXElement b) { return !a.equals(b) && a.getUri().equalsIgnoreCase(b.getUri()); } }; Set<Set<BioPAXElement>> clasters = algorithm.cluster(model.getObjects(), Integer.MAX_VALUE); // report the error once for each cluster for (Set<BioPAXElement> duplicates : clasters) { if(duplicates.size() > 1) { BioPAXElement u = duplicates.iterator().next(); duplicates.remove(u); // keep the first element error(validation, u, "duplicate.id.ignoringcase", false, duplicates, u.getModelInterface().getSimpleName()); } } }
public void check(Model model, boolean fix) { if(model.getObjects().isEmpty()) error(model, "empty.biopax.model", false, model.getLevel().toString()); }
private void createMemberEdges(CyNetwork network) { // for each PE, for (PhysicalEntity par : model.getObjects(PhysicalEntity.class)) { Set<PhysicalEntity> members = par.getMemberPhysicalEntity(); if(members.isEmpty()) continue; CyNode cyParentNode = bpeToCyNodeMap.get(par); assert cyParentNode != null : "cyParentNode is NULL."; // for each its member PE, add the directed edge for (PhysicalEntity member : members) { CyNode cyMemberNode = bpeToCyNodeMap.get(member); CyEdge edge = network.addEdge(cyParentNode, cyMemberNode, true); AttributeUtil.set(network, edge, "interaction", "member", String.class); } } }
/** * Searches a model for the given pattern, then collects the specified elements of the matches * and returns. * * @param <T> BioPAX type * @param model model to search in * @param pattern pattern to search for * @param index index of the element in the match to collect * @param c type of the element to collect * @return set of the elements at the specified index of the matching results */ public static <T extends BioPAXElement> Set<T> searchAndCollect( Model model, Pattern pattern, int index, Class<T> c) { return searchAndCollect(model.getObjects(pattern.getStartingClass()), pattern, index, c); }
private void createIndividuals(OntModel ontModel, Model model) { for (BioPAXElement bp : model.getObjects()) { String name = bp.getModelInterface().getName(); name = name.substring(name.lastIndexOf('.') + 1); OntClass ontClass = ontModel.getOntClass(this.getLevel().getNameSpace() + name); if (log.isTraceEnabled()) { log.trace("ontClass = " + ontClass); } Individual individual = ontModel.createIndividual(bp.getRDFId(), ontClass); if (log.isTraceEnabled()) { log.trace("individual = " + individual); } objectToIndividualMap.put(bp, individual); } }
public void check(final Validation validation, Model model) { if(model.getObjects().isEmpty()) error(validation, model, "empty.biopax.model", false, model.getLevel().toString()); }
private void bindObjectsToProperties(OntModel ontModel, Model model) { for (BioPAXElement bean : model.getObjects()) { Set<PropertyEditor> beanEditors = this.getEditorMap().getEditorsOf(bean); for (PropertyEditor propertyEditor : beanEditors) { insertStatement(propertyEditor, bean, ontModel); } } }
@Deprecated //does not worth it (Miriam cannot help with all DBs) private void normalizeProvenance(Model model) { // process the rest of utility classes (selectively though) for(Provenance pro : model.getObjects(Provenance.class)) { autoName(pro); // throws IAE (from MiriamLink) normalizeID(model, pro, pro.getStandardName(), null); } // replace/update elements in the model doSubs(model); }
private void createInteractionEdges(CyNetwork network) { // Extract the List of all Interactions Collection<Interaction> interactionList = model.getObjects(Interaction.class); for (Interaction itr : interactionList) { if(log.isTraceEnabled()) { log.trace("Mapping " + itr.getModelInterface().getSimpleName() + " edges : " + itr.getRDFId()); } if (itr instanceof Conversion) { addConversionInteraction(network, (Conversion)itr); } else if (itr instanceof Control) { addControlInteraction(network, (Control) itr); } else { addPhysicalInteraction(network, itr); } } }
private void createEntityNodes(CyNetwork network) { Set<Entity> entities = model.getObjects(Entity.class); for(Entity bpe: entities) { // do not make nodes for top/main pathways if(bpe instanceof Pathway) { if(bpe.getParticipantOf().isEmpty() && ((Process)bpe).getPathwayComponentOf().isEmpty()) continue; } // Create node symbolizing the interaction CyNode node = network.addNode(); bpeToCyNodeMap.put(bpe, node); // traverse createAttributesFromProperties(bpe, model, node, network); } if(log.isDebugEnabled()) log.debug(network.getRow(network).get(CyNetwork.NAME, String.class) + "" + network.getNodeList().size() + " nodes created."); }
public void check(Model model, boolean fix) { AbstractTraverser traverser = new AbstractTraverser( SimpleEditorMap.get(model.getLevel())) { @Override protected void visit(Object value, BioPAXElement parent, Model model, PropertyEditor editor) { if(value instanceof BioPAXElement && !model.contains((BioPAXElement)value)) { error(value, "dangling.value", false, editor.getDomain().getSimpleName(), editor.getProperty()); } } }; // starts from each element in the model and visits its properties for(BioPAXElement e: model.getObjects()) { traverser.traverse(e, model); } } }
private Map<String, String> calculateIdMapings(Model model) { Map<String, String> idMappings = new HashMap<String, String>(); final Set<SimplePhysicalEntity> proteins = model.getObjects(SimplePhysicalEntity.class); for (SimplePhysicalEntity protein : proteins) { final String protRefId = protein.getEntityReference().getRDFId(); for (Xref xref : protein.getXref()) { if ("uniprotkb".equals(xref.getDb())) { String newId = IDENTIFIERS_ORG + "uniprot/" + xref.getId(); idMappings.put(protRefId, newId); break; } else if ("chebi".equals(xref.getDb())) { String newId = IDENTIFIERS_ORG + xref.getDb() + "/" + xref.getId(); idMappings.put(protRefId, newId); break; } } } return idMappings; }
private void normalizeERs(Model model) { // process the rest of utility classes (selectively though) for (EntityReference bpe : model.getObjects(EntityReference.class)) { UnificationXref uref = getFirstUnificationXref(bpe); if (uref != null) // not using idVersion!.. normalizeID(model, bpe, uref.getDb(), uref.getId()); else if (log.isInfoEnabled()) log.info("Cannot normalize EntityReference: " + "no unification xrefs found in " + bpe.getRDFId() + ". " + extraInfo()); } // replace/update elements in the model doSubs(model); }
private void normalizeCVsAndBioSource(Model model) { // process the rest of utility classes (selectively though) for(UtilityClass bpe : model.getObjects(UtilityClass.class)) { if(bpe instanceof ControlledVocabulary || bpe instanceof BioSource) { //note: it does not check/fix the CV term name if wrong or missing though... UnificationXref uref = getFirstUnificationXref((XReferrable) bpe); if (uref != null) normalizeID(model, bpe, uref.getDb(), uref.getId()); // no idVersion for a CV or BS! else if(log.isInfoEnabled()) log.info("Cannot normalize " + bpe.getModelInterface().getSimpleName() + " : no unification xrefs found in " + bpe.getRDFId() + ". " + extraInfo()); } } // replace/update elements in the model doSubs(model); }
private Set<PhysicalEntity> getPEsRecursively(Set<PhysicalEntity> pes, Fetcher fetcher) { Model m = BioPAXLevel.L3.getDefaultFactory().createModel(); for(PhysicalEntity pe : pes) { if(pe instanceof Complex) fetcher.fetch(pe,m); else if(!m.containsID(pe.getRDFId())) m.add(pe); } return m.getObjects(PhysicalEntity.class); }
private Set<PhysicalEntity> getPEsRecursively(Set<PhysicalEntity> pes, Fetcher fetcher) { Model m = BioPAXLevel.L3.getDefaultFactory().createModel(); for(PhysicalEntity pe : pes) { if(pe instanceof Complex) fetcher.fetch(pe,m); else if(!m.containsID(pe.getUri())) m.add(pe); } return m.getObjects(PhysicalEntity.class); }