Changeset 5794

Timestamp:

Dec 16, 2019, 12:44:42 PM (3 years ago)

Author:

Nicklas Nordborg

Message:

References #1215: Include mutation signature analysis in the variant calling pipeline

Implemented support for parsing the output file with scores for the mutation signatures.

File:

• extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/grid/VariantCallingJobCreator.java (modified) (6 diffs)

extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/grid/VariantCallingJobCreator.java

@@ -1 +1 @@
 package net.sf.basedb.reggie.grid;
 
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.zip.GZIPInputStream;
 
@@ -573 +577 @@
         {
           FileOwner alignedOwner = FileOwner.create(dc, aligned, analysisDir);
-          pf.parseFiles(dc, alignedOwner, filesOut, Set.of("variants-callable.bed", "variants-raw.vcf.gz"));
+          msg = pf.parseFiles(dc, alignedOwner, filesOut, Set.of("variants-callable.bed", "variants-raw.vcf.gz"));
           Annotationtype.CALLABLE_BASES.setAnnotationValue(dc, aligned, pf.stat.numCallableBases);
           Annotationtype.VARIANTS_RAW.setAnnotationValue(dc, aligned, pf.stat.numRawVariants);
         }
+        Annotationtype maxMutationSignature = null;
+        Float maxScore = null;
         if (!filterSkipped)
         {
           FileOwner vCallOwner = FileOwner.create(dc, raw, analysisDir);
-          msg = pf.parseFiles(dc, vCallOwner, filesOut, Set.of("variants-annotated.vcf.gz", "variants-filtered.vcf"));
+          msg = pf.parseFiles(dc, vCallOwner, filesOut, Set.of("variants-annotated.vcf.gz", "variants-filtered.vcf", "mutation_signature.txt", "mutation_signature.pdf"));
           Annotationtype.VARIANTS_PASSED_FILTER.setAnnotationValue(dc, raw, pf.stat.numFiltered);
+          for (int index = 0; index < Annotationtype.NUM_MUTATION_SIGNATURES; index++)
+          {
+            Float score = pf.mutationSignatureScore[index];
+            if (score != null) 
+            {
+              Annotationtype.mutationSignature(index+1).setAnnotationValue(dc, raw, score);
+              if (maxScore == null || maxScore < score)
+              {
+                maxScore = score;
+                maxMutationSignature = Annotationtype.mutationSignature(index+1);
+              }
+            }
+          }
         }
 
@@ -588 +607 @@
           if (rawCallingSkipped)
           {
-            msg = "Used existing raw variants; annotated " + pf.stat.numAnnotated + " variants; " + pf.stat.numFiltered + " passed filter.";
+            msg = "Used existing raw variants; annotated " + pf.stat.numAnnotated + " variants; " + pf.stat.numFiltered + " passed filter";
           }
           else if (filterSkipped)
           {
             msg = "Found " + pf.stat.numRawVariants + " variants; skipped filtering; ";
-            msg += Values.formatNumber(pf.stat.numCallableBases/1000000f, 1) + "M callable bases.";
+            msg += Values.formatNumber(pf.stat.numCallableBases/1000000f, 1) + "M callable bases";
           }
           else
           {
-            msg = "Found " + pf.stat.numRawVariants + " variants; " + pf.stat.numFiltered + " passed filter. ";
-            msg += Values.formatNumber(pf.stat.numCallableBases/1000000f, 1) + "M callable bases.";
-          }
+            msg = "Found " + pf.stat.numRawVariants + " variants; " + pf.stat.numFiltered + " passed filter ";
+            msg += Values.formatNumber(pf.stat.numCallableBases/1000000f, 1) + "M callable bases";
+          }
+          if (maxMutationSignature != null)
+          {
+            msg += "; " + maxMutationSignature.getName() + "=" + Values.formatNumber(maxScore, 2);
+          }
+          msg += ".";
         }
         dc.commit();
@@ -690 +714 @@
     Stats stat;
     ItemSubtype vcfType;
-    DataFileType vcfData;
+    DataFileType vcfData;   
+    Float[] mutationSignatureScore = new Float[Annotationtype.NUM_MUTATION_SIGNATURES];
     
     String parseFiles(DbControl dc, FileOwner owner, String filesOut, Set<String> filenames)
@@ -742 +767 @@
           {
             link.setDescription("Created with " + software.getName());
+          }
+        }
+        if (filename.equals("mutation_signature.txt"))
+        {
+          try
+          {
+            parseMutationSignatureScores(f);
+          }
+          catch (IOException | RuntimeException ex)
+          {
+            msg = "Could not parse " + filename + " (" + ex.getMessage() + ")";
+            logger.warn("Could not parse file: " + f, ex);
           }
         }
@@ -794 +831 @@
       return vcfData;
     }
+    
+    /**
+      Parse the mutation signature file. Lines should have pattern:
+      
+      Signature.<NN><tab><score>
+      
+      where <NN> is the signature index and <score> is a positive 
+      floating point number. Lines with '0' score are parsed as null.
+    */
+    private void parseMutationSignatureScores(File f)
+      throws IOException
+    {
+      InputStream in = null;
+      try
+      {
+        Pattern p = Pattern.compile("Signature\\.(\\d+)\\t([0-9.]+)");
+        in = f.getDownloadStream(0);
+        BufferedReader r = new BufferedReader(new InputStreamReader(in, "UTF-8"));
+        
+        String line = r.readLine();
+        while (line != null)
+        {
+          Matcher m = p.matcher(line);
+          if (m.matches())
+          {
+            int index = Values.getInt(m.group(1));
+            float score = Values.getFloat(m.group(2));
+            if (score > 0 && index > 0 && index < mutationSignatureScore.length)
+            {
+              mutationSignatureScore[index] = score;
+            }
+          }
+          line = r.readLine();
+        }
+      }
+      finally
+      {
+        FileUtil.close(in);
+      }
+      
+    }
   }