Changeset 6


Ignore:
Timestamp:
Jul 10, 2012, 3:38:05 PM (7 years ago)
Author:
w.spee@…
Message:

added normal sanger color space output format as possiblity
restructured output directory structure / naming to comply with old pipeline requirements

Location:
XSQConverterJava/src/xsqconverterjava2
Files:
1 added
6 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed
  • XSQConverterJava/src/xsqconverterjava2/BWACSFastQEntry.java

    r5 r6  
    88
    99/**
    10  *
    11  * @author root
     10 * BWA specific Color Space FastQ entries
     11 * @author Wim Spee
    1212 */
    13 public class FastQEntry {
     13public class BWACSFastQEntry implements CSFastQEntryInterface {
    1414
    1515   
     
    1818    private String seqName = null;
    1919    private String description = "+";
    20     private long readNr;   
     20     
    2121   
    2222    private StringBuilder readCSSb = null;
     
    2424   
    2525   
    26     public FastQEntry()   
     26    public BWACSFastQEntry()   
    2727    {       
    2828       
     
    3838    }
    3939   
     40    @Override
    4041    public void setSeqName(String seqName)
    4142    {
     
    4445   
    4546   
     47    @Override
    4648    public void addFastQEntryPosition(int csInt, int qInt )
    4749    {
     
    9395       
    9496        return sb.toString();   
    95     }
    96 
    97     public void setReadNr(long readNr) {
    98         this.readNr = readNr;
    99     } 
    100    
    101    
    102    
    103    
    104    
    105    
    106     public void reset()
    107     {
    108        
    109     }
    110    
    111 
    112    
    113    
    114    
    115    
     97    }     
    11698   
    11799   
  • XSQConverterJava/src/xsqconverterjava2/CSFastQEntry.java

    r5 r6  
    88
    99/**
    10  *
    11  * @author root
     10 * BWA specific Color Space FastQ entries
     11 * @author Wim Spee
    1212 */
    13 public class FastQEntry {
     13public class CSFastQEntry implements CSFastQEntryInterface {
    1414
    1515   
    16     private HashMap<Integer, Character> csToBWACSMap = null;   
     16    private HashMap<Integer, Character> intToCharMap = null;   
    1717   
    1818    private String seqName = null;
    1919    private String description = "+";
    20     private long readNr;   
     20     
    2121   
    2222    private StringBuilder readCSSb = null;
     
    2424   
    2525   
    26     public FastQEntry()   
     26    public CSFastQEntry()   
    2727    {       
    28        
    29        
    30         csToBWACSMap = new HashMap<Integer,Character>();
    31         csToBWACSMap.put(0, 'A');
    32         csToBWACSMap.put(1, 'C');
    33         csToBWACSMap.put(2, 'G');
    34         csToBWACSMap.put(3, 'T'); 
     28        intToCharMap = new HashMap<Integer,Character>();
     29        intToCharMap.put(0, '0');
     30        intToCharMap.put(1, '1');
     31        intToCharMap.put(2, '2');
     32        intToCharMap.put(3, '3'); 
    3533       
    3634        readCSSb = new StringBuilder(50);
     
    3836    }
    3937   
     38    @Override
    4039    public void setSeqName(String seqName)
    4140    {
     
    4443   
    4544   
     45    @Override
    4646    public void addFastQEntryPosition(int csInt, int qInt )
    4747    {
    48         char csValue = convertCStoBWACS(csInt);
     48        char csValue = convertCSIntToCSChar(csInt);
    4949        char qValue = convertQualToBWAQual(qInt);
    5050       
    5151        if(qInt == 63)
    5252        {
    53             csValue = 'N';
     53            csValue = '.';
    5454            qValue = '"';       
    5555        }
     
    6767   
    6868   
    69     private char convertCStoBWACS(int csInt)
     69    private char convertCSIntToCSChar(int csInt)
    7070    {
    71         return csToBWACSMap.get(csInt);
     71        return intToCharMap.get(csInt);
    7272    }
    7373   
     
    9393       
    9494        return sb.toString();   
    95     }
    96 
    97     public void setReadNr(long readNr) {
    98         this.readNr = readNr;
    99     } 
    100    
    101    
    102    
    103    
    104    
    105    
    106     public void reset()
    107     {
    108        
    109     }
    110    
    111 
    112    
    113    
    114    
    115    
     95    }     
    11696   
    11797   
  • XSQConverterJava/src/xsqconverterjava2/FastQWriter.java

    r3 r6  
    2222    long readCounter = new Long(0);
    2323    Long chunkCounter = new Long(0);
    24     BufferedWriter out = null;   
     24    BufferedWriter out = null;
     25   
     26    Boolean bwaSpecific;   
    2527   
    2628   
     
    3436   
    3537   
    36     File outputDirTag;
     38    File outputDirLibTagReads;
    3739
    3840    /**
     
    4547     * @param tagName tag name that should be used in the name of the fastq files
    4648     */
    47     public FastQWriter(String libraryName, File outputDir, long chunkSize,  String tagName) {
    48         this.libraryName = libraryName;
     49    public FastQWriter(String libraryName, File outputDir, long chunkSize,  String tagName, boolean bwaSpecific) {
     50        this.libraryName = formatLibraryTagName(libraryName,tagName);
    4951//        this.dateString = dateString;
    5052//        this.laneNr = laneNr;
    5153        this.chunkSize = chunkSize;
    5254        this.tagName = tagName;
     55        this.bwaSpecific = bwaSpecific;
    5356        createOutputDir(outputDir, libraryName, tagName);
    5457       
     
    6467    private void createOutputDir(File outputDir, String libraryName, String tagName ) {
    6568       
    66         File outputDirLibrary = new File(outputDir,libraryName );
    67         outputDirLibrary.mkdir();
    68         outputDirTag = new File(outputDirLibrary,tagName );
    69         outputDirTag.mkdir();
     69        String[] libraryNameSplit = libraryName.split("_");
     70        libraryName = libraryNameSplit[0];
     71       
     72        String libAndTagOutPutDirName =  libraryName +"_"+ tagName;       
     73       
     74        File outputDirLibTag = new File(outputDir,libAndTagOutPutDirName );
     75        outputDirLibTag.mkdir();
     76        outputDirLibTagReads = new File(outputDirLibTag, "reads" );       
     77        outputDirLibTagReads.mkdir();
    7078    }
    7179   
     
    8694        chunkFileName.append("_");
    8795        chunkFileName.append(libraryName);
    88         chunkFileName.append("_");
    89         chunkFileName.append(tagName);
     96//        chunkFileName.append("_");
     97//        chunkFileName.append(tagName);
    9098//        chunkFileName.append("_");
    9199//        chunkFileName.append(dateString);
     
    93101       
    94102       
    95         File outPutChunk = new File(outputDirTag, chunkFileName.toString());
     103        File outPutChunk = new File(outputDirLibTagReads, chunkFileName.toString());
    96104        FileWriter fstream;
    97105        try {
     
    110118     * @param fastQEntry the fastq entry to write
    111119     */
    112     public void writeFastQEntry(FastQEntry fastQEntry) {
     120    public void writeFastQEntry(CSFastQEntryInterface fastQEntry) {
    113121        try {
    114122           
     
    146154        this.currentTileName = currentTileName;
    147155    }
     156   
     157    public CSFastQEntryInterface getNewEntry()
     158    {
     159        CSFastQEntryInterface cSFastQEntry = null;
     160        if(bwaSpecific)
     161        {
     162            cSFastQEntry = new BWACSFastQEntry();
     163        }
     164        else
     165        {
     166            cSFastQEntry= new CSFastQEntry();
     167        }
     168        return cSFastQEntry;
     169    }
     170   
     171
     172    public void setBwaSpecific(Boolean bwaSpecific) {
     173        this.bwaSpecific = bwaSpecific;
     174    }
     175   
     176    public long getReadCounter()
     177    {
     178        return readCounter;
     179    }
     180   
     181    private String formatLibraryTagName(String libraryName, String tagName)
     182    {
     183        String[] libraryNameSplit = libraryName.split("_");
     184        libraryName = libraryNameSplit[0];
     185       
     186        String libAndTagName =  libraryName +"_"+ tagName;
     187        return libAndTagName;
     188       
     189    }
     190
     191    public String getLibraryName() {
     192        return libraryName;
     193    }
     194
     195    public String getTagName() {
     196        return tagName;
     197    }
     198   
     199   
     200   
     201   
     202   
    148203
    149204
  • XSQConverterJava/src/xsqconverterjava2/Library.java

    r3 r6  
    3232    * @return
    3333    */
    34     public long processLibrary(Map<String, FastQWriter> fastQWriterPerTag)
     34    public long processLibrary(Map<String, FastQWriter> fastQWriterPerTag, Map<String, Integer> usedTags)
    3535    {
    3636                           
     
    4343        {
    4444            Tile tile = new Tile((Group)tileObject);
    45             readCounter += tile.processTile(fastQWriterPerTag);
     45            readCounter += tile.processTile(fastQWriterPerTag, usedTags);
    4646            tileCounter++;                           
    4747        }
  • XSQConverterJava/src/xsqconverterjava2/Tags.java

    r3 r6  
    44 */
    55package xsqconverterjava2;
     6
    67
    78import java.util.HashMap;
     
    1213import ncsa.hdf.object.Group;
    1314import ncsa.hdf.object.h5.H5ScalarDS;
     15import ncsa.hdf.object.Dataset;
    1416
    1517/**
     
    2123    private static Map<String, String> validTags = null;
    2224   
    23     Group tagGroup = null;   
     25    Group tagGroup = null;   
     26    Integer numColorBase = 0;
    2427       
    2528   
    26     public Tags(Group fragmentGroup){
     29    public Tags(Group fragmentGroup, Integer numColorBase){
    2730        this.tagGroup = fragmentGroup;
     31        this.numColorBase = numColorBase;
    2832       
    2933        createValidTagsMap();
     
    4246       
    4347       
    44         String tagName = tagGroup.getName();       
    45         byte[] byteArray = getByteArrayFromFragment(tagGroup);       
     48        String tagName = tagGroup.getName();   
     49       
     50        H5ScalarDS readsAndQuals = (H5ScalarDS)tagGroup.getMemberList().get(0);     
     51             
     52       
     53        byte[] byteArray = getByteArrayFromFragment(readsAndQuals);       
    4654       
    4755        int byteArrayPos = 0;
    4856        long readNr = 1;
    4957       
    50         FastQEntry fastQEntry = new FastQEntry();
    51         fastQEntry.setReadNr(readNr);       
     58        CSFastQEntryInterface fastQEntry = fastQWriter.getNewEntry();
    5259       
     60       
    5361       
    5462        //loop over all bytes
    5563        for (byte byteVQ :byteArray )
    5664        {
    57             //if the previous byteArray position was 50 print the fastqEntry
    58             if(byteArrayPos % 50 == 0 && byteArrayPos != 0)
     65            //if the previous byteArray position was numColorBase print the fastqEntry
     66            if(byteArrayPos % numColorBase == 0 && byteArrayPos != 0)
    5967            {
    6068               fastQWriter.writeFastQEntry(fastQEntry);
    6169               readNr++;               
    6270               
    63                fastQEntry = new FastQEntry();
    64                fastQEntry.setReadNr(readNr);
     71               fastQEntry = fastQWriter.getNewEntry();               
    6572                         
    6673            }           
     
    8289   
    8390   
     91   
     92   
    8493    /**
    8594     * Reads the byte array from the dataset under this tag
     
    8796     * @return the byte array
    8897     */
    89     private static byte[] getByteArrayFromFragment(Group fragment) {
    90         H5ScalarDS readsAndQuals = (H5ScalarDS)fragment.getMemberList().get(0);       
    91        
     98    private static byte[] getByteArrayFromFragment(H5ScalarDS readsAndQuals) {
     99                       
    92100        byte[] byteArray = null;
    93101        try {
  • XSQConverterJava/src/xsqconverterjava2/Tile.java

    r3 r6  
    2828     * @return
    2929     */
    30     public long processTile(Map<String, FastQWriter> fastQWriterPerTag)
     30    public long processTile(Map<String, FastQWriter> fastQWriterPerTag, Map<String, Integer> usedTags)
    3131    {
    3232        List tagList = tileGroup.getMemberList(); 
     
    4141        for(Object tileMember : tagList)
    4242        {
    43            Group fragmentGroup = (Group)tileMember;
     43           String tileMemberName = tileMember.toString();
     44           
    4445           
    4546           Boolean matchUsedtags= false;
    4647           for(String usedTag : fastQWriterPerTag.keySet())
    4748           {
    48                if(tileMember.toString().equalsIgnoreCase(usedTag))
     49               if(tileMemberName.equalsIgnoreCase(usedTag))
    4950               {
    5051                   matchUsedtags = true;
     
    5556           if(matchUsedtags)
    5657           {
    57                Tags tag = new Tags(fragmentGroup);
     58               Group fragmentGroup = (Group)tileMember;
     59               Tags tag = new Tags(fragmentGroup, usedTags.get(tileMemberName));
    5860               readCounter += tag.processTag(fastQWriterPerTag.get(tileMember.toString()));
    5961           }
  • XSQConverterJava/src/xsqconverterjava2/XSQConverterJava.java

    r5 r6  
    3434        options.addOption("d", false, "display all libraries names");
    3535        options.addOption("j", false, "display Java path");
     36        options.addOption("f", true, "fastQ dialect / format. Either BWA or Sanger." );
    3637       
    3738       
     
    5758            xSQFile.printAllRootSubGroups();
    5859            System.exit(0);
    59         }
    60              
     60        }             
    6161       
    6262       
     
    6464        {
    6565            printHelp(options);           
    66         }       
     66        } 
     67       
     68        if(!fastQformatIsSpecified(cmd))
     69        {
     70            printHelp(options);
     71        }
     72        Boolean bwaSpecific = false;
     73        if(cmd.getOptionValue("f").equalsIgnoreCase("bwa"))
     74        {
     75            bwaSpecific = true;
     76        };
     77         
    6778       
    6879        String xsqFilePath = cmd.getOptionValue("i");
     
    7081        long chunkSize =  new Long(cmd.getOptionValue("c", "1000000"));   
    7182//       
    72        
    73        
    74        
    75        
    76        
    77 //        String xsqFilePath = "/home/wim/Analysis/xsq_conversion_test/HU02_20120518_MixedRunRNA4CChIP_Nico_05.xsq";
    78 //        String outputPath = "/home/wim/Analysis/xsq_conversion_test/HU02_output6";
     83       
     84       
     85       
     86//        String xsqFilePath = "/home/wim/Analysis/xsq_conversion_test/errorSet/UMC007_20111027_ExomesRubenPool9xMP_Ivo_01.xsq";
     87//        String outputPath = "/home/wim/Analysis/xsq_conversion_test/errorSet/test2/java";
    7988//        long chunkSize =  new Long(1000000000);
     89//        Boolean bwaSpecific = true;
     90       
     91       
     92//        XSQFile xSQFile = new XSQFile(xsqFilePath);           
     93//        xSQFile.printAllRootSubGroups();
     94//        System.exit(0);
     95       
    8096       
    8197        Map<String, String> librariesSubSet = new HashMap<String, String>();
     
    86102                librariesSubSet.put(object.toString(), null);               
    87103            }
    88         }
    89        
    90        
    91        
    92        
     104        }       
    93105       
    94106       
     
    101113        createOutputDir(outputPath);
    102114        XSQFile xSQFile = new XSQFile(xsqFilePath);
    103         xSQFile.processXSQFile(outputDir, chunkSize, librariesSubSet);
     115        xSQFile.processXSQFile(outputDir, chunkSize, librariesSubSet, bwaSpecific);
    104116               
    105117       
     
    127139       
    128140        if(!cmd.hasOption("i")){ requiredOptionsAreSet = false; }
    129         if(!cmd.hasOption("o")){ requiredOptionsAreSet = false; }       
    130        
     141        if(!cmd.hasOption("o")){ requiredOptionsAreSet = false; } 
     142        if(!cmd.hasOption("f")){ requiredOptionsAreSet = false; } 
    131143        return requiredOptionsAreSet;
     144       
     145    }
     146   
     147    private static boolean fastQformatIsSpecified(CommandLine cmd) {
     148        Boolean fastQFormatIsSet = false;
     149       
     150        if(cmd.getOptionValue("f").equalsIgnoreCase("bwa")){fastQFormatIsSet = true;}
     151        if(cmd.getOptionValue("f").equalsIgnoreCase("sanger")){fastQFormatIsSet = true;}
     152        return fastQFormatIsSet;
    132153       
    133154    }
     
    171192        System.out.println(path);
    172193    }
     194
     195   
    173196   
    174197    /**
  • XSQConverterJava/src/xsqconverterjava2/XSQFile.java

    r3 r6  
    55package xsqconverterjava2;
    66
     7
    78import java.io.File;
    8 import java.util.ArrayList;
    9 import java.util.HashMap;
    10 import java.util.List;
    11 import java.util.Map;
     9import java.io.FileWriter;
     10import java.io.IOException;
     11import java.util.*;
    1212import java.util.logging.Level;
    1313import java.util.logging.Logger;
    1414import javax.swing.tree.DefaultMutableTreeNode;
     15import ncsa.hdf.hdf5lib.exceptions.HDF5Exception;
    1516import ncsa.hdf.object.Group;
    1617import ncsa.hdf.object.HObject;
    1718import ncsa.hdf.object.h5.H5File;
     19import ncsa.hdf.object.h5.H5CompoundDS;
     20
    1821
    1922/**
     
    2629    String XSQFilePath = null;
    2730    H5File xsqFile = null;
    28     List<String> usedTags = null;
     31    Map<String, Integer> usedTags = null;
     32   
     33    File outputDir = null;
    2934   
    3035//    String laneNr = null;
     
    3338   
    3439    Group rootGroup = null;
     40
     41    StringBuilder metrics = new StringBuilder();
    3542
    3643   
     
    4754//        setLaneNrAndDateBasedOnFileName(XSQFilePath);
    4855        openFile();
    49         getUsedTags();
     56        try {
     57            getUsedTags();
     58        } catch (HDF5Exception ex) {
     59            Logger.getLogger(XSQFile.class.getName()).log(Level.SEVERE, null, ex);
     60            ex.printStackTrace();
     61        }
    5062       
    5163    }   
     
    7789        try {
    7890            // open the file and retrieve the root group
    79             xsqFile.open();
     91           openFile2();
    8092            rootGroup = (Group)(( DefaultMutableTreeNode)xsqFile.getRootNode()).getUserObject();
    8193        } catch (Exception ex) {
     
    8698    }
    8799   
     100    private void openFile2() throws Exception
     101    {
     102         xsqFile.open();       
     103         
     104    }
     105   
     106   
     107   
     108   
    88109    /**
    89110     * Gets the used tags from runmetadata->tagdetails node.
    90111     */
    91     private void getUsedTags() {
    92        
    93         usedTags = new ArrayList<String>();
     112    private void getUsedTags() throws HDF5Exception {
     113       
     114        usedTags = new HashMap<String, Integer>();
    94115           
    95116        Group runMetadataGroup = null;
     
    115136        }
    116137       
    117         for (Object tagGroup :tagDetailsGroup.getMemberList() )
    118         {
    119             usedTags.add(tagGroup.toString());
     138        for (Object tag :tagDetailsGroup.getMemberList() )
     139        {
     140            Group tagGroup = (Group) tag;
     141            H5CompoundDS dataSetEncoding = (H5CompoundDS) tagGroup.getMemberList().get(0);
     142           
     143            Vector dataSetEncodingVector =  (Vector)dataSetEncoding.read();
     144            long[] numBaseCallArray = (long[])dataSetEncodingVector.get(4);
     145            Integer numCSBaseCalls = (int)numBaseCallArray[0];               
     146               
     147               
     148         
     149           
     150            usedTags.put(tagGroup.toString(), numCSBaseCalls);
    120151        }
    121152       
     
    129160     * @param chunkSize the chunksize to use for splitting the output fastQ files.
    130161     */
    131     public void processXSQFile(File outputDir, long chunkSize, Map<String, String> librariesSubSetMap) {
    132        
     162    public void processXSQFile(File outputDir, long chunkSize, Map<String, String> librariesSubSetMap, boolean BWASpecific) {
     163       
     164        this.outputDir = outputDir;
    133165        List libraries = libraries = getLibraries(rootGroup, false);  ;
    134166        if(!librariesSubSetMap.isEmpty())
    135167        {
    136168           libraries = getLibrarySubset(libraries, librariesSubSetMap);           
    137         }
    138            
    139        
     169        }
    140170               
    141         processLibraries(libraries, outputDir, chunkSize, usedTags);       
     171        processLibraries(libraries, outputDir, chunkSize, usedTags, BWASpecific);       
    142172    }
    143173   
     
    165195     * @param libraries the list of libraries to process
    166196     */
    167     private  void processLibraries(List libraries, File outputDir,long chunkSize, List<String> usedTags)
    168     {
    169         long readCounter = 0;
     197    private  void processLibraries(List libraries, File outputDir,long chunkSize, Map<String,Integer> usedTags, boolean bwaSpecific)
     198    {
     199        long totalReadCounter = 0;
    170200        for(Object libraryObject : libraries)
    171201        {           
    172            Library library = new Library((Group)libraryObject);
     202           Library library = new Library((Group)libraryObject); 
    173203           
    174204           Map<String, FastQWriter> fastQWriterPerTag = new HashMap<String, FastQWriter>();
    175            for(String tag : usedTags)
     205           for(String tag : usedTags.keySet())
    176206           {
    177 //               fastQWriterPerTag.put(tag, new FastQWriter(libraryObject.toString(), outputDir, chunkSize, dateString, laneNr, tag));
    178                fastQWriterPerTag.put(tag, new FastQWriter(libraryObject.toString(), outputDir, chunkSize, tag));
     207//             fastQWriterPerTag.put(tag, new FastQWriter(libraryObject.toString(), outputDir, chunkSize, dateString, laneNr, tag));
     208               fastQWriterPerTag.put(tag, new FastQWriter(libraryObject.toString(), outputDir, chunkSize, tag, bwaSpecific));
     209           }           
     210           
     211           
     212           long libraryReadCount = library.processLibrary(fastQWriterPerTag,usedTags);
     213           totalReadCounter += libraryReadCount;
     214           
     215           //for
     216           for(FastQWriter fastQWriter: fastQWriterPerTag.values() )
     217           {
     218               metrics.append(fastQWriter.getLibraryName());
     219               metrics.append("\t");
     220               metrics.append(fastQWriter.getReadCounter());
     221               metrics.append("\n");
     222               System.out.println("Processed tag "+ fastQWriter.getTagName() + "with "+fastQWriter.getReadCounter()+" reads"); 
    179223           }
    180224           
    181            
    182            
    183            readCounter += library.processLibrary(fastQWriterPerTag);
    184         }
    185         System.out.println("Processed "+libraries.size() + "libraries and a total of "+readCounter+" reads"); 
    186     }
     225                   
     226           
     227        }
     228        System.out.println("Processed "+libraries.size() + "libraries and a total of "+totalReadCounter+" reads"); 
     229        printMetrics();
     230       
     231    }   
     232   
    187233   
    188234    /**
     
    270316    }
    271317   
     318    private void printMetrics() {
     319        System.out.println(metrics);   
     320       
     321        File metricsFile = new File(outputDir,"conversionMetrics.txt" );
     322        try {
     323           FileWriter  fstream = new FileWriter(metricsFile);
     324            fstream.write(metrics.toString());
     325             fstream.close();
     326        } catch (IOException ex) {
     327            Logger.getLogger(XSQFile.class.getName()).log(Level.SEVERE, null, ex);
     328        }
     329       
     330       
     331       
     332    }
     333   
    272334   
    273335   
Note: See TracChangeset for help on using the changeset viewer.