scbi_fqbin 0.2.2 → 0.2.3

data/lib_fqbin_src/other/bwxform.h

@@ -0,0 +1,74 @@
+/***************************************************************************
+*               Header for Burrows-Wheeler Transform Library
+*
+*   File    : bwxform.h
+*   Purpose : Provides that apply and reverse the Burrows-Wheeler transform
+*             (with or without move to front coding/decoding.
+*             transformation).
+*   Author  : Michael Dipperstein
+*   Date    : August 20, 2004
+*
+****************************************************************************
+*   UPDATES
+*
+*   $Id: bwxform.h,v 1.3 2007/09/17 13:21:19 michael Exp $
+*   $Log: bwxform.h,v $
+*   Revision 1.3  2007/09/17 13:21:19  michael
+*   Changes required for LGPL v3.
+*
+*   Revision 1.2  2005/05/02 13:35:49  michael
+*   Update e-mail address.
+*
+*   Revision 1.1.1.1  2004/08/23 04:34:18  michael
+*   Burrows-Wheeler Transform
+*
+****************************************************************************
+*
+* bwxform: An ANSI C Burrows-Wheeler Transform/Reverse Transform Routines
+* Copyright (C) 2004-2005, 2007 by
+* Michael Dipperstein (mdipper@alumni.engr.ucsb.edu)
+*
+* This file is part of the BWT library.
+*
+* The BWT library is free software; you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published
+* by the Free Software Foundation; either version 3 of the License, or (at
+* your option) any later version.
+*
+* The BWT library 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 Lesser
+* General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+***************************************************************************/
+
+#ifndef _BWXFORM_H_
+#define _BWXFORM_H_
+
+/***************************************************************************
+*                                CONSTANTS
+***************************************************************************/
+#ifndef FALSE
+#define FALSE       0
+#endif
+
+#ifndef TRUE
+#define TRUE        1
+#endif
+
+/***************************************************************************
+*                               PROTOTYPES
+***************************************************************************/
+ /* Transform inFile */
+int BWXformFile(char *inFile, char *outFile, char mtf);
+
+/* Reverse Transform inFile*/
+int BWReverseXformFile(char *inFile, char *outFile, char mtf);
+
+int BWXform(char *inString, char *outString, int mtf);
+int BWReverseXform(char *inString, char *outString, int mtf, long size);
+
+#endif  /* ndef _BWXFORM_H_ */

data/lib_fqbin_src/other/find_in_index.c

@@ -0,0 +1,130 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <zlib.h>
+#include <zlib.h>
+#include <stdlib.h>
+
+// Maximum file name (including .idx)
+#define MAXFNAME 512
+
+// Maximum lenght of the name of a sequence
+#define MAXSEQNAME 1024
+#define MAXSEQLENGTH 150000000
+#define DEBUG 1
+#define FALSE 0 
+#define TRUE 1 
+
+#define INVALID_FASTQ_FORMAT -5
+#define INVALID_FASTA_FORMAT -6
+
+#define SEQ_METADATA 10000
+
+
+// int mystrcmp(const char *a,const char *b)
+// {
+//   return strlen(a)-strlen(b)?strlen(a)-strlen(b):strcmp(a,b);
+// }
+
+
+int first_line(gzFile file, line){
+    
+    
+    
+}
+
+
+
+long long find_seq_in_hash(char *filename,char *sname)
+{
+
+  char file_name[MAXFNAME];
+  // char indexname[MAXFNAME];
+  int error;
+  char sname1[MAXSEQNAME];// sequence name
+  char sname2[MAXSEQNAME];// sequence name
+  long long gz_chunk=0;
+  char tmp[SEQ_METADATA];
+  long long res=-1;
+
+  // to save min, max sequences and current chunk
+  char min_name[MAXSEQNAME];
+  char max_name[MAXSEQNAME];
+  long long current_chunk=0;
+  
+
+  strcpy(min_name,"");
+  strcpy(max_name,"");
+
+  // calc index and hash name
+  // snprintf(indexname,MAXFNAME,"%s.index",filename);
+  snprintf(file_name,MAXFNAME,"%s.index",filename);
+  
+  // open index and hash file
+  gzFile gzhash_file=gzopen(file_name,"r");
+  
+  if (gzhash_file==NULL) {
+  	fprintf(stderr,"error opening gzhash_file :%s\n",gzerror(gzhash_file,&error));
+  	return -2;
+  }
+  
+  // repeat until EOF
+  while ( gzgets(gzhash_file,tmp,sizeof(tmp))!=Z_NULL ) {
+    
+      // printf("%s\n",tmp);
+    // parse string
+    int reads=sscanf(tmp,"%s %s %lld",sname1,sname2,&gz_chunk);
+
+    if(reads==3) // valid index line
+    {
+        // 
+        if((mystrcmp(sname,sname1)>=0) && (mystrcmp(sname,sname2)<=0))
+        {
+            printf("%s in [%s,%s]\n",sname,sname1,sname2);
+            res = gz_chunk;
+            break;
+        }else{
+            printf("%s NOT IN [%s,%s]\n",sname,sname1,sname2);
+        }
+        
+    }
+        
+  }
+  
+  // close files
+  gzclose(gzhash_file);
+  
+  return res;
+}
+
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+  // check params
+  if (argc!=3)
+  {
+    printf("Usage %s fbin_index_file seq_name\n\n",argv[0]);
+    return -1;
+  }
+  
+  int c1=mystrcmp("SRR314795.1","SRR314795.1000000");
+  int c2=mystrcmp("SRR314795.1000000","SRR314795.9");
+  printf("RES: %d,%d\n",c1,c2);
+  
+  long long chunk=find_seq_in_hash(argv[1],argv[2]);
+  
+  printf("Chunk: %lld\n",chunk);
+  
+}
+

data/lib_fqbin_src/other/hash_fbin_nogzchunks.c

@@ -0,0 +1,164 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <zlib.h>
+#include <zlib.h>
+#include <stdlib.h>
+
+// Maximum file name (including .idx)
+#define MAXFNAME 512
+
+// Maximum lenght of the name of a sequence
+#define MAXSEQNAME 1024
+#define MAXSEQLENGTH 150000000
+#define DEBUG 1
+#define FALSE 0 
+#define TRUE 1 
+
+#define INVALID_FASTQ_FORMAT -5
+#define INVALID_FASTA_FORMAT -6
+
+#define SEQ_METADATA 10000
+
+// creates a hash from an index file with the desired chunk size. Chunk size can be 
+// adjusted to fit a good compromise between access speed and used space.
+int hash_index_file(char *filename, int chunk_size, int skip_sort)
+{
+
+  char hash_file_name[MAXFNAME];
+  char indexname[MAXFNAME];
+  
+  char sname[MAXSEQNAME];// sequence name
+  long long beginH, gz_chunk=0;
+  char tmp[SEQ_METADATA];
+  int res=0;
+  int error;
+
+  // to save min, max sequences and current chunk
+  char min_name[MAXSEQNAME];
+  char max_name[MAXSEQNAME];
+  long long current_chunk=0;
+  long long count=0;
+  
+
+  strcpy(min_name,"");
+  strcpy(max_name,"");
+
+	// calc index and hash name
+  snprintf(indexname,MAXFNAME,"%s.index",filename);
+  snprintf(hash_file_name,MAXFNAME,"%s.index.hash",filename);
+  
+  // sort index file by external  command
+  if(skip_sort==0)
+  {
+      char cmd[10000];
+      snprintf(cmd,10000,"sort_index.sh %s",indexname);
+      system(cmd);
+  }
+
+  // use sorted index
+  // snprintf(indexname,MAXFNAME,"%s.index.sort",filename);
+  
+  // open index and hash file
+  gzFile gzhash_file=gzopen(hash_file_name,"wb");
+  gzFile gzfile_index=gzopen(indexname,"r");
+  
+  if (gzfile_index==NULL) {
+	fprintf(stderr,"error opening gzfile_index :%s\n",gzerror(gzfile_index,&error));
+	return -2;
+  }
+  
+  if (gzhash_file==NULL) {
+  	fprintf(stderr,"error opening gzhash_file :%s\n",gzerror(gzhash_file,&error));
+  	return -2;
+  }
+  
+  // repeat until EOF
+  while ( gzgets(gzfile_index,tmp,sizeof(tmp))!=Z_NULL ) {
+    
+    // parse string
+    sscanf(tmp,"%s %lld %lld",sname,&gz_chunk,&beginH);
+
+    if(strcmp(sname,"UMACOMPRESSEDFORMAT")!=0) // valid index line
+    {
+    
+        // clear chunk_data if any
+        // if (gz_chunk!=current_chunk){
+        if ((count%chunk_size)==0){
+            if (strcmp(min_name,"")!=0){
+                // there are data to write
+                res=gzprintf(gzhash_file,"%s %s %lld\n",min_name,max_name,current_chunk);
+            }
+            strcpy(min_name,"");
+            strcpy(max_name,"");
+            // current_chunk=gz_chunk;
+            current_chunk = gztell(gzfile_index);
+        }
+
+        // save min_name
+    	if((strcmp(min_name,"")==0) || (strcmp(sname,min_name)<0))
+    	{
+            // replace min_name
+            strcpy(min_name,sname);
+    	}
+	
+    	//save max_name
+    	if((strcmp(max_name,"")==0) || (strcmp(sname,max_name)>0))
+    	{
+            strcpy(max_name,sname);
+      }
+        
+      count++;
+    }
+        
+  }
+  
+  if (strcmp(min_name,"")!=0){
+      // there are data to write
+      res=gzprintf(gzhash_file,"%s %s %lld\n",min_name,max_name,current_chunk);
+  }
+  
+  // close files
+  gzclose(gzhash_file);
+  gzclose(gzfile_index);
+  
+  return 0;
+}
+
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+  // check params
+  if (argc<2)
+  {
+    printf("Usage %s fbin_file [chunk_size [--skip_sort]]\n\n",argv[0]);
+    return -1;
+  }
+  
+  int chunk_size=10000;
+  int skip_sort=0;
+  
+  if(argc==3){
+      chunk_size=atoi(argv[2]);
+  }
+  
+  if (argc==4){
+      skip_sort=1;
+  }
+  
+  int res=hash_index_file(argv[1],chunk_size, skip_sort);
+  
+  return res;
+}
+

data/lib_fqbin_src/other/idx_fqbin.c

@@ -0,0 +1,67 @@
+#include "lib_fqbin.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+
+#include <unistd.h>
+
+
+void usage(){
+    printf("Usage: idx_fqbin fqbin_file\n\n");
+    // printf("    -f    Output sequence in fasta format\n\n");
+    
+    exit(-1);
+    
+}
+
+/*******************************************************/
+/* main                                                */
+/*******************************************************/
+int main(int argc, char *argv[])
+{
+
+    char *fasta=NULL;
+    char *qual=NULL;
+    char *extras=NULL;
+    int size=5000;
+    int res=0;
+
+    int ch;
+
+    int output_fasta = 0;
+    int output_qual = 0;
+
+    while ((ch = getopt(argc, argv, "h")) != -1) {
+            switch (ch) {
+            case 'h':
+                    usage();
+                    break;
+            case '?':
+            default:
+                    usage();
+            }
+    }
+
+    argc -= optind;
+    argv += optind;
+    // printf("argc: %d", argc);
+    // printf("argv: %s", argv[0]);
+
+    if (argc!=1)
+    {
+        usage();
+    }
+
+
+    if (regenerate_index(argv[0])==-1){
+        printf("File %s does not exists",argv[0]);
+        exit(-1);
+    }
+
+    exit(0);
+
+}
+

data/lib_fqbin_src/other/make_hsh.sh

@@ -0,0 +1,14 @@
+# La entrada a fichero es el nombre del fichero sin extensión
+
+# crea un fichero con los bloques existentes 
+rm $1.hsh
+zmore $1.index | awk '{if ( FNR!=1 ) print $2}' |sort -n|uniq > $1.tmp
+
+for block in `cat $1.tmp` ; do
+        minmax=`zegrep "^[^[:space:]]* $block " $1.index|awk ' \
+             BEGIN { MIN="ZZZZZZZZZZZZZZZZZZZZZZZZZZZ";MAX=""} \
+             {if ((MIN>$1) && ($1!="" )) MIN=$1; \
+              if (MAX<$1) MAX=$1;nlines++ } \
+             END {print MIN,MAX}'` 
+echo $minmax $block >> $1.hsh
+done