Java Code
/*
* Copyright: (c) 2004-2009 Mayo Foundation for Medical Education and
* Research (MFMER). All rights reserved. MAYO, MAYO CLINIC, and the
* triple-shield Mayo logo are trademarks and service marks of MFMER.
*
* Except as contained in the copyright notice above, or as used to identify
* MFMER as the author of this software, the trade names, trademarks, service
* marks, or product names of the copyright holder shall not be used in
* advertising, promotion or otherwise in connection with this software without
* prior written authorization of the copyright holder.
*
* Licensed under the Eclipse Public License, Version 1.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
*/
package org.LexGrid.LexBIG.example;
import org.LexGrid.LexBIG.DataModel.Collections.AssociationList;
import org.LexGrid.LexBIG.DataModel.Collections.ResolvedConceptReferenceList;
import org.LexGrid.LexBIG.DataModel.Core.AssociatedConcept;
import org.LexGrid.LexBIG.DataModel.Core.Association;
import org.LexGrid.LexBIG.DataModel.Core.CodingSchemeSummary;
import org.LexGrid.LexBIG.DataModel.Core.CodingSchemeVersionOrTag;
import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference;
import org.LexGrid.LexBIG.Exceptions.LBException;
import org.LexGrid.LexBIG.Impl.LexBIGServiceImpl;
import org.LexGrid.LexBIG.LexBIGService.CodedNodeGraph;
import org.LexGrid.LexBIG.LexBIGService.CodedNodeSet;
import org.LexGrid.LexBIG.LexBIGService.LexBIGService;
import org.LexGrid.LexBIG.LexBIGService.CodedNodeSet.PropertyType;
import org.LexGrid.LexBIG.Utility.ConvenienceMethods;
import org.LexGrid.commonTypes.PropertyQualifier;
import org.LexGrid.commonTypes.Text;
import org.LexGrid.concepts.Concept;
import org.LexGrid.concepts.Entity;
import org.LexGrid.concepts.Presentation;
/**
* Example showing any source-asserted hierarchies (based on import of MRHIER
* HCD) for a CUI. The program takes a single argument (the UMLS CUI), prompts
* for the code system to query in the LexGrid repository, and displays the
* available hierarchical relationships.
*/
public class FindUMLSContextsForCUI {
static String[] hierAssocNames_ = new String[] { "PAR", "CHD", "hasSubtype", "isa", "branch_of", "part_of",
"tributary_of" };
public FindUMLSContextsForCUI() {
super();
}
/**
* Entry point for processing.
*
* @param args
*/
public static void main(String[] args) {
if (args.length < 1) {
System.out.println("Example: FindUMLSContextsForCUI \"C0030920\"");
return;
}
try {
String cui = args[0];
new FindUMLSContextsForCUI().run(cui);
} catch (Exception e) {
Util.displayAndLogError("REQUEST FAILED !!!", e);
}
}
/**
* Process the provided code.
*
* @param code
* @throws LBException
*/
public void run(String cui) throws LBException {
CodingSchemeSummary css = Util.promptForCodeSystem();
if (css != null) {
LexBIGService lbSvc = LexBIGServiceImpl.defaultInstance();
String scheme = css.getCodingSchemeURI();
CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
csvt.setVersion(css.getRepresentsVersion());
ResolvedConceptReference ref = printCode(cui, lbSvc, scheme, csvt);
if (ref != null)
printContext(ref, lbSvc, scheme, csvt);
}
}
/**
* Display name and description information for the given cui.
*
* @param code
* @param lbSvc
* @param scheme
* @param csvt
* @return A fully resolved concept reference for the code.
* @throws LBException
*/
protected ResolvedConceptReference printCode(String cui, LexBIGService lbSvc, String scheme,
CodingSchemeVersionOrTag csvt) throws LBException {
// Locate the matching concept ...
CodedNodeSet cns = lbSvc.getCodingSchemeConcepts(scheme, csvt);
cns.restrictToMatchingProperties(ConvenienceMethods.createLocalNameList("UMLS_CUI"),
new PropertyType[] { PropertyType.GENERIC }, cui, "exactMatch", null);
ResolvedConceptReferenceList cnsList = cns.resolveToList(null, // sort
// options
null, // property names
new PropertyType[] { PropertyType.PRESENTATION }, // property
// types
1);
if (cnsList.getResolvedConceptReferenceCount() == 0) {
Util.displayMessage("Unable to find code for CUI = '" + cui + "'");
return null;
}
ResolvedConceptReference rcr = cnsList.getResolvedConceptReference(0);
Util.displayMessage("Concept code: " + rcr.getConceptCode());
Util.displayMessage("Description : " + rcr.getEntityDescription().getContent());
return rcr;
}
/**
* Recursively display each context that the code participates in with
* additional information.
*
* @param rcr
* @param lbSvc
* @param scheme
* @param csvt
* @throws LBException
*/
protected void printContext(ResolvedConceptReference rcr, LexBIGService lbSvc, String scheme,
CodingSchemeVersionOrTag csvt) throws LBException {
Entity node = rcr.getEntity();
// Step through the presentations and evaluate any tagged with
// hcd(s) one by one ...
int hcdsFound = 0;
for (int i = 0; i < node.getPresentationCount(); i++) {
Presentation pres = node.getPresentation(i);
PropertyQualifier[] quals = pres.getPropertyQualifier();
for (int q = 0; q < quals.length; q++) {
PropertyQualifier qual = quals[q];
if (qual.getPropertyQualifierName().equalsIgnoreCase("HCD")) {
Text hcd = qual.getValue();
Util.displayMessage("");
Util.displayMessage("HCD: " + hcd);
hcdsFound++;
// Define a code set for all concepts tagged with the HCD.
CodedNodeSet hcdConceptMatch = lbSvc.getCodingSchemeConcepts(scheme, csvt);
hcdConceptMatch.restrictToProperties(null, // property names
new PropertyType[] { PropertyType.PRESENTATION }, // property
// types
null, // source list
null, // context list
ConvenienceMethods.createNameAndValueList("HCD", hcd.toString()) // qualifier
// list
);
// Define a code graph for all relations tagged with the
// HCD.
CodedNodeGraph hcdGraph = lbSvc.getNodeGraph(scheme, csvt, "UMLS_Relations");
// Now restrict the code graph based on the code set (so,
// exclude
// nodes that do not contain the desired tag).
CodedNodeGraph hcdTargeted = hcdGraph.restrictToTargetCodes(hcdConceptMatch);
hcdTargeted.restrictToAssociations(ConvenienceMethods.createNameAndValueList(hierAssocNames_),
ConvenienceMethods.createNameAndValueList("HCD", hcd.toString()));
ResolvedConceptReference[] links = hcdTargeted.resolveAsList(null, // graph
// focus
true, // resolve forward
false, // resolve backward
Integer.MAX_VALUE, // coded entry depth
-1, // association depth
null, // property names
new PropertyType[] { PropertyType.PRESENTATION }, // property
// types
null, // sort options
500 // max to return
).getResolvedConceptReference();
// Resolve and print the chain of terms ...
for (int j = 0; j < links.length; j++) {
ResolvedConceptReference link = links[j];
StringBuffer sb = new StringBuffer(getItemText(link, hcd.toString()));
printAssociationList(sb, hcd.toString(), link.getSourceOf(), 0, true);
printAssociationList(sb, hcd.toString(), link.getTargetOf(), 0, false);
Util.displayMessage(sb.toString());
}
}
}
}
if (hcdsFound == 0) {
Util.displayMessage("No hierarchical tags (HCD properties) found.");
return;
}
}
/**
* Add text to the given string buffer by recursing the hierarchy and
* appending text for each included concept.
*
* @param sb
* StringBuffer to receive the text for the entire list.
* @param hcd
* The hierarchical code to reflect in printed output.
* @param al
* The list to process.
* @param depth
* Current depth of recursion (0=no recursion yet).
* @param fwd
* True if processing relations in a forward direction (source to
* target); False otherwise (target to source).
*/
protected void printAssociationList(StringBuffer sb, String hcd, AssociationList al, int depth, boolean fwd) {
if (al != null && al.getAssociationCount() > 0) {
Association[] aList = al.getAssociation();
for (int i = 0; i < aList.length; i++) {
AssociatedConcept[] acList = aList[i].getAssociatedConcepts().getAssociatedConcept();
for (int j = 0; j < acList.length; j++) {
AssociatedConcept ac = acList[j];
// Indent on new line according to depth ...
sb.append('\n');
for (int d = 0; d < depth; d++)
sb.append(" ");
// Add the code and text for this link ...
sb.append("->").append(getItemText(ac, hcd));
// Recurse to get the entire chain
printAssociationList(sb, hcd, fwd ? ac.getSourceOf() : ac.getTargetOf(), depth + 1, fwd);
}
}
}
}
/**
* Returns the text representing the given item. Note that in general this
* method assumes the presentations have been constrianed during the initial
* query by HCD qualification.
*
* @param rcr
* Concept resolved from a query.
* @param hcd
* The hierarchical code to reflect in printed output.
* @return The first embedded text presentation, or the item description if
* no presentation is found.
*/
protected String getItemText(ResolvedConceptReference rcr, String hcd) {
StringBuffer sb = new StringBuffer(rcr.getConceptCode());
boolean presFound = false;
if (rcr.getEntity() != null) {
Presentation[] presentations = rcr.getEntity().getPresentation();
for (int i = 0; i < presentations.length && !presFound; i++) {
Presentation p = presentations[i];
PropertyQualifier[] quals = p.getPropertyQualifier();
for (int j = 0; j < quals.length && !presFound; j++) {
PropertyQualifier pq = quals[j];
if (presFound = "HCD".equals(pq.getPropertyQualifierName())
&& hcd.equals(pq.getValue().getContent())) {
sb.append(':').append(p.getValue().getContent());
}
}
}
}
if (!presFound && rcr.getEntityDescription() != null)
sb.append(':').append(rcr.getEntityDescription().getContent());
return sb.toString();
}
}
