From: Jim Procter Date: Tue, 10 Jun 2014 16:26:30 +0000 (+0100) Subject: JAL-1379 a JPred v3.0.1 client via JABA 2.1 X-Git-Tag: Jalview_2_9~182^2 X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=7b45ebcb44dd677bd13bc7f74aca9554edd10f50;p=jalview.git JAL-1379 a JPred v3.0.1 client via JABA 2.1 --- diff --git a/src/jalview/ws/jws2/JPred301Client.java b/src/jalview/ws/jws2/JPred301Client.java new file mode 100644 index 0000000..71cbb7e --- /dev/null +++ b/src/jalview/ws/jws2/JPred301Client.java @@ -0,0 +1,231 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) + * Copyright (C) 2014 The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.ws.jws2; + +import jalview.api.AlignCalcWorkerI; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.Annotation; +import jalview.gui.AlignFrame; +import jalview.ws.jws2.jabaws2.Jws2Instance; +import jalview.ws.params.ArgumentI; +import jalview.ws.params.OptionI; +import jalview.ws.params.WsParamSetI; +import jalview.ws.uimodel.AlignAnalysisUIText; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; + +import compbio.data.sequence.FastaSequence; +import compbio.data.sequence.JpredAlignment; +import compbio.metadata.Argument; + +public class JPred301Client extends JabawsMsaInterfaceAlignCalcWorker + implements AlignCalcWorkerI +{ + + /** + * + * @return default args for this service when run as dynamic web service + */ + public List selectDefaultArgs() + { + List rgs = new ArrayList(); + for (ArgumentI argi: service.getParamStore().getServiceParameters()) + { + if (argi instanceof OptionI) + { + List o = ((OptionI) argi).getPossibleValues(); + if (o.contains("-pred-nohits")) + { + OptionI cpy = ((OptionI)argi).copy(); + cpy.setValue("-pred-nohits"); + rgs.add(cpy); + } + } + } + return JabaParamStore.getJabafromJwsArgs(rgs); + } + + public JPred301Client(Jws2Instance service, AlignFrame alignFrame, + WsParamSetI preset, List paramset) + { + super(service, alignFrame, preset, paramset); + submitGaps = true; + alignedSeqs = true; + nucleotidesAllowed = false; + proteinAllowed = true; + gapMap = new boolean[0]; + updateParameters(null, selectDefaultArgs()); + } + + @Override + boolean checkValidInputSeqs(boolean dynamic, List seqs) + { + return (seqs.size() > 1); + } + + public String getServiceActionText() + { + return "calculating consensus secondary structure prediction using JPred service"; + } + private static HashMap jpredRowLabels = new HashMap(); + private static HashSetjpredRes_graph,jpredRes_ssonly; + { + jpredRes_ssonly=new HashSet(); + jpredRes_ssonly.add("jnetpred".toLowerCase()); + jpredRes_graph=new HashSet(); + jpredRes_graph.add("jnetconf".toLowerCase()); + + } + /** + * update the consensus annotation from the sequence profile data using + * current visualization settings. + */ + public void updateResultAnnotation(boolean immediate) + { + if (immediate || !calcMan.isWorking(this) && msascoreset != null) + { + if (msascoreset instanceof compbio.data.sequence.JpredAlignment) + { + JpredAlignment jpres = (JpredAlignment) msascoreset; + int alWidth = alignViewport.getAlignment().getWidth(); + ArrayList ourAnnot = new ArrayList(); + for (FastaSequence fsq:jpres.getJpredSequences()) + { + String[] k = jpredRowLabels.get(fsq.getId()); + if (k==null) + { + k = new String[] { fsq.getId(), "JNet Output"}; + } + createAnnotationRowFromString(ourAnnot, getCalcId(), alWidth, + k[0],k[1], + jpredRes_graph.contains(fsq.getId()) ? AlignmentAnnotation.BAR_GRAPH : AlignmentAnnotation.NO_GRAPH, 0f, 0f, + fsq.getSequence()); + + } + for (FastaSequence fsq: jpres.getSequences()) + { + if (fsq.getId().equalsIgnoreCase("QUERY")) + { + createAnnotationRowFromString(ourAnnot, getCalcId(), alWidth, + "Query", "JPred Reference Sequence", + AlignmentAnnotation.NO_GRAPH, 0f, 0f, + fsq.getSequence()); + } + } + if (ourAnnot.size() > 0) + { + updateOurAnnots(ourAnnot); + } + } + } + } + + private void createAnnotationRowFromString( + ArrayList ourAnnot, String calcId, + int alWidth, String label, String descr, int rowType, float min, + float max, String jpredPrediction) + { + // simple annotation row + AlignmentAnnotation annotation = alignViewport.getAlignment() + .findOrCreateAnnotation(label, calcId, true, null, null); + if (alWidth == gapMap.length) // scr.getScores().size()) + { + annotation.label = new String(label); + annotation.description = new String(descr); + annotation.graph = rowType; + annotation.graphMin = min; + annotation.graphMax = max; + if (constructAnnotationFromString(annotation, jpredPrediction, + alWidth, rowType)) + { + // created a valid annotation from the data + ourAnnot.add(annotation); + } + } + } + + private boolean constructAnnotationFromString( + AlignmentAnnotation annotation, String sourceData, int alWidth, + int rowType) + { + if (sourceData.length()==0 && alWidth>0) + { + return false; + } + Annotation[] elm = new Annotation[alWidth]; + + for (int i = 0, iSize = sourceData.length(); i < iSize; i++) + { + char annot = sourceData.charAt(i); + // if we're at a gapped column then skip to next ungapped position + if (gapMap != null && gapMap.length > 0) + { + while (!gapMap[i]) + { + elm[i++] = new Annotation("", "", ' ', Float.NaN); + } + } + switch (rowType) + { + case AlignmentAnnotation.NO_GRAPH: + elm[i] = new Annotation("" + annot, "" + annot, annot, Float.NaN); + break; + default: + try + { + elm[i] = new Annotation("" + annot, "" + annot, annot, + Integer.valueOf(annot)); + } catch (Exception x) + { + System.err.println("Expected numeric value in character '" + + annot + "'"); + } + } + } + + annotation.annotations = elm; + annotation.belowAlignment = true; + annotation.validateRangeAndDisplay(); + return true; + } + + @Override + public String getCalcId() + { + return CALC_ID; + } + + private static String CALC_ID = "jabaws21.JPred3Cons"; + + public static AlignAnalysisUIText getAlignAnalysisUITest() + { + return new AlignAnalysisUIText( + compbio.ws.client.Services.JpredWS.toString(), + jalview.ws.jws2.JPred301Client.class, CALC_ID, false, true, + true, "JPred Consensus", + "When checked, JPred consensus is updated automatically.", + "Change JPred Settings...", + "Modify settings for JPred calculations."); + } +} diff --git a/src/jalview/ws/jws2/JabawsMsaInterfaceAlignCalcWorker.java b/src/jalview/ws/jws2/JabawsMsaInterfaceAlignCalcWorker.java new file mode 100644 index 0000000..1f0d92c --- /dev/null +++ b/src/jalview/ws/jws2/JabawsMsaInterfaceAlignCalcWorker.java @@ -0,0 +1,225 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) + * Copyright (C) 2014 The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ +package jalview.ws.jws2; + +import java.util.Iterator; +import java.util.List; + +import compbio.data.msa.MsaWS; +import compbio.data.msa.SequenceAnnotation; +import compbio.data.sequence.Alignment; +import compbio.data.sequence.Score; +import compbio.data.sequence.ScoreManager; +import compbio.metadata.Argument; +import compbio.metadata.ChunkHolder; +import compbio.metadata.JobStatus; +import compbio.metadata.JobSubmissionException; +import compbio.metadata.ResultNotAvailableException; +import compbio.metadata.WrongParameterException; +import jalview.api.AlignViewportI; +import jalview.api.AlignmentViewPanel; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.Annotation; +import jalview.datamodel.SequenceI; +import jalview.gui.AlignFrame; +import jalview.workers.AlignCalcWorker; +import jalview.ws.jws2.jabaws2.Jws2Instance; +import jalview.ws.params.WsParamSetI; + +public abstract class JabawsMsaInterfaceAlignCalcWorker extends AbstractJabaCalcWorker +{ + + @SuppressWarnings("unchecked") + protected MsaWS msaservice; + + protected Alignment msascoreset; + + public JabawsMsaInterfaceAlignCalcWorker(AlignViewportI alignViewport, + AlignmentViewPanel alignPanel) + { + super(alignViewport, alignPanel); + } + + public JabawsMsaInterfaceAlignCalcWorker(Jws2Instance service, AlignFrame alignFrame, + WsParamSetI preset, List paramset) + { + this(alignFrame.getCurrentView(), alignFrame.alignPanel); + this.guiProgress = alignFrame; + this.preset = preset; + this.arguments = paramset; + this.service = service; + msaservice = (MsaWS) service.service; + + } + + @Override + ChunkHolder pullExecStatistics(String rslt, long rpos) + { + return msaservice.pullExecStatistics(rslt, rpos); + } + + @Override + boolean collectAnnotationResultsFor(String rslt) + throws ResultNotAvailableException + { + msascoreset = msaservice.getResult(rslt); + if (msascoreset != null) + { + return true; + } + return false; + } + + @Override + boolean cancelJob(String rslt) throws Exception + { + return msaservice.cancelJob(rslt); + } + + @Override + protected JobStatus getJobStatus(String rslt) throws Exception + { + return msaservice.getJobStatus(rslt); + } + + @Override + boolean hasService() + { + return msaservice != null; + } + + @Override + protected boolean isInteractiveUpdate() + { + return false; // this instanceof AAConClient; + } + + @Override + protected String submitToService( + List seqs) + throws JobSubmissionException + { + String rslt; + if (preset == null && arguments == null) + { + rslt = msaservice.align(seqs); + } + else + { + try + { + rslt = msaservice.customAlign(seqs, getJabaArguments()); + } catch (WrongParameterException x) + { + throw new JobSubmissionException( + "Invalid parameter set. Check Jalview implementation.", x); + + } + } + return rslt; + } + + protected void createAnnotationRowsForScores( + List ourAnnot, String calcId, int alWidth, + Score scr) + { + // simple annotation row + AlignmentAnnotation annotation = alignViewport.getAlignment() + .findOrCreateAnnotation(scr.getMethod(), calcId, true, null, + null); + if (alWidth == gapMap.length) // scr.getScores().size()) + { + constructAnnotationFromScore(annotation, 0, alWidth, scr); + ourAnnot.add(annotation); + } + } + + protected AlignmentAnnotation createAnnotationRowsForScores( + List ourAnnot, String typeName, + String calcId, SequenceI dseq, int base, Score scr) + { + System.out.println("Creating annotation on dseq:" + dseq.getStart() + + " base is " + base + " and length=" + dseq.getLength() + + " == " + scr.getScores().size()); + // AlignmentAnnotation annotation = new AlignmentAnnotation( + // scr.getMethod(), typeName, new Annotation[] + // {}, 0, -1, AlignmentAnnotation.LINE_GRAPH); + // annotation.setCalcId(calcId); + AlignmentAnnotation annotation = alignViewport.getAlignment() + .findOrCreateAnnotation(typeName, calcId, false, dseq, null); + constructAnnotationFromScore(annotation, 0, dseq.getLength(), scr); + annotation.createSequenceMapping(dseq, base, false); + annotation.adjustForAlignment(); + dseq.addAlignmentAnnotation(annotation); + ourAnnot.add(annotation); + return annotation; + } + + private void constructAnnotationFromScore(AlignmentAnnotation annotation, + int base, int alWidth, Score scr) + { + Annotation[] elm = new Annotation[alWidth]; + Iterator vals = scr.getScores().iterator(); + float m = 0f, x = 0f; + for (int i = 0; vals.hasNext(); i++) + { + float val = vals.next().floatValue(); + if (i == 0) + { + m = val; + x = val; + } + else + { + if (m > val) + { + m = val; + } + ; + if (x < val) + { + x = val; + } + } + // if we're at a gapped column then skip to next ungapped position + if (gapMap != null && gapMap.length > 0) + { + while (!gapMap[i]) + { + elm[i++] = new Annotation("", "", ' ', Float.NaN); + } + } + elm[i] = new Annotation("", "" + val, ' ', val); + } + + annotation.annotations = elm; + annotation.belowAlignment = true; + if (x < 0) + { + x = 0; + } + x += (x - m) * 0.1; + annotation.graphMax = x; + annotation.graphMin = m; + annotation.validateRangeAndDisplay(); + } + +} diff --git a/src/jalview/ws/jws2/Jws2Discoverer.java b/src/jalview/ws/jws2/Jws2Discoverer.java index 206bdc8..144a860 100644 --- a/src/jalview/ws/jws2/Jws2Discoverer.java +++ b/src/jalview/ws/jws2/Jws2Discoverer.java @@ -135,7 +135,7 @@ public class Jws2Discoverer implements Runnable, WSMenuEntryProviderI // first set up exclusion list if needed final Set ignoredServices = new HashSet(); for (String ignored : jalview.bin.Cache.getDefault( - "IGNORED_JABAWS_SERVICETYPES", Services.JpredWS.toString()) + "IGNORED_JABAWS_SERVICETYPES", "") .split("\\|")) { ignoredServices.add(ignored); diff --git a/src/jalview/ws/jws2/jabaws2/Jws2InstanceFactory.java b/src/jalview/ws/jws2/jabaws2/Jws2InstanceFactory.java index db50a9d..bcc7735 100644 --- a/src/jalview/ws/jws2/jabaws2/Jws2InstanceFactory.java +++ b/src/jalview/ws/jws2/jabaws2/Jws2InstanceFactory.java @@ -23,8 +23,8 @@ package jalview.ws.jws2.jabaws2; import java.util.HashMap; import compbio.data.msa.JABAService; - import jalview.ws.jws2.AAConClient; +import jalview.ws.jws2.JPred301Client; import jalview.ws.jws2.RNAalifoldClient; import jalview.ws.uimodel.AlignAnalysisUIText; @@ -47,6 +47,8 @@ public class Jws2InstanceFactory AAConClient.getAlignAnalysisUITest()); aaConGUI.put(compbio.ws.client.Services.RNAalifoldWS.toString(), RNAalifoldClient.getAlignAnalysisUITest()); + aaConGUI.put(compbio.ws.client.Services.JpredWS.toString(), + JPred301Client.getAlignAnalysisUITest()); } }