Beispiel #1
0
func (s *S) TestReadFasta(c *check.C) {
	r := fasta.NewReader(strings.NewReader(fa), linear.NewSeq("", nil, alphabet.Protein))
	m, _ := multi.NewMulti("", nil, seq.DefaultConsensus)
	a, err := NewReader(r, m).Read()
	c.Check(err, check.Equals, nil)
	c.Check(a.Rows(), check.Equals, 11)
}
Beispiel #2
0
func (s *S) TestReadFromFunc(c *check.C) {
	var (
		obtainNfa []string
		obtainSfa [][]alphabet.Letter
	)

	sc := seqio.NewScannerFromFunc(
		fasta.NewReader(
			bytes.NewBufferString(testaln0),
			linear.NewSeq("", nil, alphabet.Protein),
		).Read,
	)
	for sc.Next() {
		t := sc.Seq().(*linear.Seq)
		header := t.Name()
		if desc := t.Description(); len(desc) > 0 {
			header += " " + desc
		}
		obtainNfa = append(obtainNfa, header)
		obtainSfa = append(obtainSfa, t.Slice().(alphabet.Letters))
	}
	c.Check(sc.Error(), check.Equals, nil)
	c.Check(obtainNfa, check.DeepEquals, expectNfa)
	for i := range obtainSfa {
		c.Check(len(obtainSfa[i]), check.Equals, len(expectSfa[i]))
		c.Check(obtainSfa[i], check.DeepEquals, expectSfa[i])
	}
}
Beispiel #3
0
func main() {
	flag.Parse()
	if *exclude == "" {
		flag.Usage()
		os.Exit(1)
	}

	nameSet := make(map[string]struct{})
	f, err := os.Open(*exclude)
	if err != nil {
		log.Fatalf("failed to open exclude file %q: %v", *exclude, err)
	}
	ls := bufio.NewScanner(f)
	for ls.Scan() {
		nameSet[ls.Text()] = struct{}{}
	}
	err = ls.Err()
	if err != nil {
		log.Fatalf("failed to read exclude file: %v", err)
	}

	sc := seqio.NewScanner(fasta.NewReader(os.Stdin, linear.NewSeq("", nil, alphabet.DNA)))
	for sc.Next() {
		s := sc.Seq().(*linear.Seq)
		if _, ok := nameSet[s.ID]; ok {
			continue
		}
		fmt.Printf("%60a\n", s)
	}
	if err := sc.Error(); err != nil {
		log.Fatalf("error during gff read: %v", err)
	}
}
Beispiel #4
0
func main() {
	flag.Parse()
	if *in == "" {
		flag.Usage()
		os.Exit(1)
	}

	f, err := os.Open(*in)
	if err != nil {
		log.Fatalf("failed to open %q: %v", *in, err)
	}
	events := make(map[string][]*gff.Feature)
	fsc := featio.NewScanner(gff.NewReader(f))
	for fsc.Next() {
		f := fsc.Feat().(*gff.Feature)
		fields := strings.Fields(f.FeatAttributes.Get("Read"))
		if len(fields) != 3 {
			log.Fatalf("bad record: %+v", f)
		}
		events[fields[0]] = append(events[fields[0]], f)
	}
	if err := fsc.Error(); err != nil {
		log.Fatalf("error during gff read: %v", err)
	}
	f.Close()

	for _, ref := range flag.Args() {
		f, err = os.Open(ref)
		if err != nil {
			log.Fatalf("failed to open reference %q: %v", ref, err)
		}
		ssc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNA)))
		for ssc.Next() {
			seq := ssc.Seq().(*linear.Seq)
			for _, f := range events[seq.Name()] {
				fields := strings.Fields(f.FeatAttributes.Get("Read"))
				if len(fields) != 3 {
					log.Fatalf("bad record: %+v", f)
				}
				start, err := strconv.Atoi(fields[1])
				if err != nil {
					log.Fatalf("failed to get start coordinate: %v", err)
				}
				end, err := strconv.Atoi(fields[2])
				if err != nil {
					log.Fatalf("failed to get end coordinate: %v", err)
				}
				tmp := *seq
				tmp.ID += fmt.Sprintf("//%d_%d", start, end)
				tmp.Seq = tmp.Seq[start:end]
				fmt.Printf("%60a\n", &tmp)
			}
		}
		if err := ssc.Error(); err != nil {
			log.Fatalf("error during fasta read: %v", err)
		}
		f.Close()
	}
}
Beispiel #5
0
func getFasta(fn string) (seq.Sequence, error) {
	fasta_file, err := os.Open(fn)
	if err != nil {
		fmt.Println("Erro ao ler o arquivo", err)
	}
	defer fasta_file.Close()
	var s []alphabet.Letter
	t := linear.NewSeq("", s, alphabet.Protein)
	reader := fasta.NewReader(fasta_file, t)
	seq, _ := reader.Read()
	return seq, nil
}
Beispiel #6
0
// writeFlankSeqs writes fasta files containing the sequence of unmapped flanks
// identified in the primary hits provided. cutoff specifies the minimum sequence
// length to consider. left and right specify the filenames for the left and right
// flank fasta sequence files.
func writeFlankSeqs(reads string, hits hitSet, cutoff int, left, right string) error {
	f, err := os.Open(reads)
	if err != nil {
		return err
	}
	defer f.Close()

	lf, err := os.Create(left)
	if err != nil {
		return err
	}
	rf, err := os.Create(right)
	if err != nil {
		return err
	}

	r := fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNA))
	sc := seqio.NewScanner(r)
	for sc.Next() {
		seq := sc.Seq().(*linear.Seq)
		h, ok := hits[seq.Name()]
		if !ok {
			continue
		}

		all := seq.Seq
		if h.qStart >= cutoff {
			seq.Seq = all[:h.qStart]
			_, err := fmt.Fprintf(lf, "%60a\n", seq)
			if err != nil {
				return err
			}
		}
		if h.qLen-h.qEnd >= cutoff {
			seq.Seq = all[h.qEnd:]
			_, err := fmt.Fprintf(rf, "%60a\n", seq)
			if err != nil {
				return err
			}
		}
	}
	err = sc.Error()
	if err != nil {
		return err
	}
	err = lf.Close()
	if err != nil {
		return err
	}
	return rf.Close()
}
Beispiel #7
0
func readFasta(fn string) (name string, seq string, err error) {
	fFasta, err := os.Open(fn)
	defer fFasta.Close()
	if err != nil {
		return "", "", err
	}
	t := linear.NewSeq("", nil, alphabet.Protein)
	reader := fasta.NewReader(fFasta, t)
	s, err := reader.Read()
	if err != nil {
		return "", "", err
	}
	sl := s.(*linear.Seq)
	return sl.Name(), sl.String(), nil
}
Beispiel #8
0
func readContigs(file string) (map[string]*linear.Seq, error) {
	f, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	seqs := make(map[string]*linear.Seq)
	sc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNAgapped)))
	for sc.Next() {
		s := sc.Seq().(*linear.Seq)
		seqs[s.ID] = s
	}
	if err != nil {
		return nil, err
	}
	return seqs, nil
}
Beispiel #9
0
func readContigs(file string) (map[string]int, error) {
	f, err := os.Open(file)
	if err != nil {
		return nil, err
	}
	lengths := make(map[string]int)
	sc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNA)))
	for sc.Next() {
		s := sc.Seq()
		lengths[s.Name()] = s.Len()
	}
	if err != nil {
		log.Fatalf("error during fasta read: %v", err)
	}
	return lengths, nil
}
Beispiel #10
0
func main() {
	flag.Parse()
	if *in == "" {
		flag.Usage()
		os.Exit(1)
	}

	f, err := os.Open(*in)
	if err != nil {
		log.Fatalf("failed to open %q: %v", *in, err)
	}
	defer f.Close()

	names := make(map[string][]string)

	sc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNAgapped)))
	for sc.Next() {
		seq := sc.Seq().(*linear.Seq)
		idx := strings.LastIndex(seq.ID, "/")
		names[seq.ID[:idx]] = append(names[seq.ID[:idx]], seq.ID[idx+1:])
	}
	if err := sc.Error(); err != nil {
		log.Fatalf("error during fasta read: %v", err)
	}
	f.Close()

	base := filepath.Base(*in)
	unique, err := os.Create(base + ".unique.text")
	if err != nil {
		log.Fatalf("failed to create %q: %v", base+".unique.text", err)
	}
	defer unique.Close()
	nonUnique, err := os.Create(base + ".non-unique.text")
	if err != nil {
		log.Fatalf("failed to create %q: %v", base+".non-unique.text", err)
	}
	defer nonUnique.Close()
	for name, coords := range names {
		switch len(coords) {
		case 0:
		case 1:
			fmt.Fprintln(unique, name)
		default:
			fmt.Fprintf(nonUnique, "%s\t%v\n", name, coords)
		}
	}
}
Beispiel #11
0
func main() {
	flag.Parse()
	if *in == "" {
		flag.Usage()
		os.Exit(1)
	}

	inFile, err := os.Open(*in)
	if err != nil {
		log.Fatalf("failed to open input:%v", err)
	}
	defer inFile.Close()
	*in = filepath.Base(*in)

	sc := seqio.NewScanner(fasta.NewReader(inFile, linear.NewSeq("", nil, alphabet.DNA)))

	var i, size int
	out, err := os.Create(fmt.Sprintf("%s-%d.fa", *in, i))
	for sc.Next() {
		if sc.Seq().Len() < *cut {
			continue
		}
		if size != 0 && size+sc.Seq().Len() > *bundle {
			err = out.Close()
			if err != nil {
				log.Fatalf("failed to close file bundle %d: %v", i, err)
			}
			i++
			size = 0
			out, err = os.Create(fmt.Sprintf("%s-%d.fa", *in, i))
			if err != nil {
				log.Fatalf("failed to open file bundle %d: %v", i, err)
			}
		}
		size += sc.Seq().Len()
		fmt.Fprintf(out, "%60a\n", sc.Seq())
	}
	if sc.Error() != nil {
		log.Fatal(sc.Error())
	}
	err = out.Close()
	if err != nil {
		log.Fatalf("failed to close file bundle %d: %v", i, err)
	}
}
Beispiel #12
0
func BenchmarkSWAlign(b *testing.B) {
	t := &linear.Seq{}
	t.Alpha = alphabet.DNAgapped
	r := fasta.NewReader(strings.NewReader(crspFa), t)
	swsa, _ := r.Read()
	swsb, _ := r.Read()

	smith := SW{
		{2, -1, -1, -1, -1},
		{-1, 2, -1, -1, -1},
		{-1, -1, 2, -1, -1},
		{-1, -1, -1, 2, -1},
		{-1, -1, -1, -1, 0},
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		smith.Align(swsa, swsb)
	}
}
Beispiel #13
0
func BenchmarkNWAlign(b *testing.B) {
	t := &linear.Seq{}
	t.Alpha = alphabet.DNAgapped
	r := fasta.NewReader(strings.NewReader(crspFa), t)
	nwsa, _ := r.Read()
	nwsb, _ := r.Read()

	needle := NW{
		{10, -3, -1, -4, -5},
		{-3, 9, -5, 0, -5},
		{-1, -5, 7, -3, -5},
		{-4, 0, -3, 8, -5},
		{-4, -4, -4, -4, 0},
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		needle.Align(nwsa, nwsb)
	}
}
Beispiel #14
0
func mangle() {
	seen := make(map[string]bool)
	hash := sha1.New()
	sc := seqio.NewScanner(fasta.NewReader(os.Stdin, linear.NewSeq("", nil, alphabet.DNA)))
	for sc.Next() {
		s := sc.Seq().(*linear.Seq)
		if s.Desc == "" {
			s.Desc = s.ID
		} else {
			s.Desc = fmt.Sprintf("%s %s", s.ID, s.Desc)
		}
		hash.Write([]byte(s.Desc))
		s.ID = fmt.Sprintf("%040x", hash.Sum(nil))
		if seen[s.ID] {
			log.Fatalf("duplicate sha1: %s", s.ID)
		}
		seen[s.ID] = true
		hash.Reset()
		fmt.Printf("%60a\n", s)
	}
}
Beispiel #15
0
func main() {
	flag.Parse()
	if *in == "" || *typ < 0 || 2 < *typ {
		flag.Usage()
		os.Exit(1)
	}

	cfn := []func(s seq.Sequence, start, end int) (float64, error){
		0: complexity.WF,
		1: complexity.Entropic,
		2: complexity.Z,
	}[*typ]

	f, err := os.Open(*in)
	if err != nil {
		log.Fatalf("failed to open %q: %v", *in, err)
	}
	defer f.Close()

	sc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNAgapped)))
	for sc.Next() {
		seq := sc.Seq().(*linear.Seq)

		// err is always nil for a linear.Seq Start() and End().
		c, _ := cfn(seq, seq.Start(), seq.End())

		if *dist {
			fmt.Printf("%s\t%v\t%d\n", seq.Name(), c, seq.Len())
			continue
		}
		if c >= *thresh {
			fmt.Printf("%60a\n", seq)
		}
	}
	if err := sc.Error(); err != nil {
		log.Fatalf("error during fasta read: %v", err)
	}
}
Beispiel #16
0
func BenchmarkSWAffineAlign(b *testing.B) {
	b.StopTimer()
	t := &linear.Seq{}
	t.Alpha = alphabet.DNAgapped
	r := fasta.NewReader(strings.NewReader(crspFa), t)
	swsa, _ := r.Read()
	swsb, _ := r.Read()

	smith := SWAffine{
		Matrix: Linear{
			{2, -1, -1, -1, -1},
			{-1, 2, -1, -1, -1},
			{-1, -1, 2, -1, -1},
			{-1, -1, -1, 2, -1},
			{-1, -1, -1, -1, 0},
		},
		GapOpen: -5,
	}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		smith.Align(swsa, swsb)
	}
}
func consensus(in io.Reader) (*linear.QSeq, *multi.Multi, error) {
	m, err := muscle.Muscle{Quiet: true}.BuildCommand()
	if err != nil {
		return nil, nil, err
	}
	m.Stdin = in
	buf := &bytes.Buffer{}
	m.Stdout = buf
	err = m.Run()
	if err != nil {
		return nil, nil, err
	}
	var (
		r  = fasta.NewReader(buf, &linear.Seq{Annotation: seq.Annotation{Alpha: alphabet.DNA}})
		ms = &multi.Multi{ColumnConsense: seq.DefaultQConsensus}
	)
	sc := seqio.NewScanner(r)
	for sc.Next() {
		ms.Add(sc.Seq())
	}

	return ms.Consensus(true), ms, sc.Error()
}
Beispiel #18
0
func unmangle(mapfile string) {
	table := make(map[string]string)
	sc := seqio.NewScanner(fasta.NewReader(os.Stdin, linear.NewSeq("", nil, alphabet.DNA)))
	for sc.Next() {
		s := sc.Seq().(*linear.Seq)
		id := strings.Fields(s.Desc)[0]
		if id == "" {
			log.Fatalf("no id for sequence %s", s.ID)
		}
		table[s.ID] = id
	}

	f, err := os.Open(mapfile)
	if err != nil {
		log.Fatalf("failed to open map file %q: %v", mapfile, err)
	}
	s := bufio.NewScanner(f)
	for s.Scan() {
		line := s.Text()
		fields := strings.Fields(line)
		if len(fields) <= *queryNameField {
			log.Fatalf("unexpected number of fields in line %q", line)
		}
		id := table[fields[*queryNameField]]
		if id == "" {
			log.Fatalf("no id for map query %s", fields[*queryNameField])
		}
		fields[*queryNameField] = id
		for i, f := range fields {
			if i != 0 {
				fmt.Print("\t")
			}
			fmt.Print(f)
		}
		fmt.Println()
	}
}
Beispiel #19
0
func BenchmarkNWAffineAlign(b *testing.B) {
	b.StopTimer()
	t := &linear.Seq{}
	t.Alpha = alphabet.DNAgapped
	r := fasta.NewReader(strings.NewReader(crspFa), t)
	nwsa, _ := r.Read()
	nwsb, _ := r.Read()

	needle := NWAffine{
		Matrix: Linear{
			{10, -3, -1, -4, -5},
			{-3, 9, -5, 0, -5},
			{-1, -5, 7, -3, -5},
			{-4, 0, -3, 8, -5},
			{-4, -4, -4, -4, 0},
		},
		GapOpen: -10,
	}

	b.StartTimer()
	for i := 0; i < b.N; i++ {
		needle.Align(nwsa, nwsb)
	}
}
Beispiel #20
0
func main() {
	flag.Var(&alnmat, "align", "specify the match, mismatch and gap parameters")
	flag.Parse()
	if *in == "" {
		flag.Usage()
		os.Exit(1)
	}

	f, err := os.Open(*in)
	if err != nil {
		log.Fatalf("failed to open %q: %v", *in, err)
	}
	events := make(map[string][]*gff.Feature)
	fsc := featio.NewScanner(gff.NewReader(f))
	for fsc.Next() {
		f := fsc.Feat().(*gff.Feature)
		fields := strings.Fields(f.FeatAttributes.Get("Read"))
		if len(fields) != 3 {
			log.Fatalf("bad record: %+v", f)
		}
		events[fields[0]] = append(events[fields[0]], f)
	}
	if err := fsc.Error(); err != nil {
		log.Fatalf("error during gff read: %v", err)
	}
	f.Close()

	w := gff.NewWriter(os.Stdout, 60, true)
	w.WriteComment("Right coordinates (field 5) and strand (field 7) are hypothetical.")

	var out *os.File
	if *fastaOut != "" {
		out, err = os.Create(*fastaOut)
		if err != nil {
			log.Fatalf("failed to create fasta insertion output file %q: %v", *fastaOut, err)
		}
		defer out.Close()
	}

	hw := *window / 2
	sw := makeTable(alphabet.DNAgapped, alnmat)
	for _, ref := range flag.Args() {
		f, err = os.Open(ref)
		if err != nil {
			log.Fatalf("failed to open reference %q: %v", ref, err)
		}
		ssc := seqio.NewScanner(fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNAgapped)))
	loop:
		for ssc.Next() {
			seq := ssc.Seq().(*linear.Seq)
			for _, f := range events[seq.Name()] {
				fields := strings.Fields(f.FeatAttributes.Get("Read"))
				if len(fields) != 3 {
					log.Fatalf("bad record: %+v", f)
				}
				start, err := strconv.Atoi(fields[1])
				if err != nil {
					log.Fatalf("failed to get start coordinate: %v", err)
				}
				end, err := strconv.Atoi(fields[2])
				if err != nil {
					log.Fatalf("failed to get end coordinate: %v", err)
				}

				if out != nil {
					insert := *seq
					if insert.Desc != "" {
						insert.Desc += " "
					}
					insert.Desc += fmt.Sprintf("[%d,%d)", start, end)
					insert.Seq = insert.Seq[start:end]
					fmt.Fprintf(out, "%60a\n", &insert)
				}

				var lOff, lEnd, rOff, rEnd int
				// If we have refined ends, use them.
				if dup := f.FeatAttributes.Get("Dup"); dup != "" {
					d, err := strconv.Atoi(dup)
					if err != nil {
						log.Fatalf("failed to get duplication length: %v", err)
					}
					lOff = max(0, start-d)
					lEnd = start
					rOff = end
					rEnd = min(len(seq.Seq), end+d)
				} else {
					lOff = max(0, start-hw)
					lEnd = min(len(seq.Seq), start+hw)
					rOff = max(0, end-hw)
					rEnd = min(len(seq.Seq), end+hw)

					// Ensure windows don't overlap.
					if lEnd > rOff {
						lEnd = (lEnd + rOff) / 2
						rOff = lEnd
					}
				}

				if lEnd-lOff < *thresh || rEnd-rOff < *thresh {
					// Don't do fruitless work.
					continue loop
				}

				left := *seq
				left.ID = "prefix"
				left.Seq = left.Seq[lOff:lEnd]
				right := *seq
				right.ID = "postfix"
				right.Seq = right.Seq[rOff:rEnd]

				aln, err := sw.Align(&right, &left)
				if err != nil {
					log.Fatal(err)
				}

				fa := align.Format(&right, &left, aln, '-')
				for _, seg := range fa {
					var n int
					for _, l := range seg.(alphabet.Letters) {
						if l != '-' {
							n++
						}
					}
					if n < *thresh {
						continue loop
					}
				}

				var sc int
				for _, seg := range aln {
					type scorer interface {
						Score() int
					}
					sc += seg.(scorer).Score()
				}
				f.FeatAttributes = append(f.FeatAttributes, gff.Attribute{
					Tag: "TSD", Value: fmt.Sprintf(`%v %d %d %v "%v" %d`,
						fa[0], aln[len(aln)-1].Features()[0].End()+lOff,
						aln[0].Features()[1].Start()+rOff, fa[1],
						aln, sc),
				})
				w.Write(f)
			}
		}
		if err := ssc.Error(); err != nil {
			log.Fatalf("error during fasta read: %v", err)
		}
		f.Close()
	}
}
func main() {
	flag.IntVar(&maxFam, "maxFam", 0, "maxFam indicates maximum family size considered (0 == no limit).")
	flag.BoolVar(&subSample, "subsample", false, "choose maxFam members of a family if the family has more than maxFam members.")
	flag.BoolVar(&consFasta, "fasta", false, "output consensus as fasta with quality case filtering.")
	flag.StringVar(&cDir, "cDir", "", "target directory for consensus output. If not empty Dir is deleted first.")
	flag.StringVar(&aDir, "aDir", "", "target directory for alignment output. If not empty dir is deleted first.")
	flag.StringVar(&sDir, "sDir", "", "target directory for sequence information output. If not empty dir is deleted first.")
	flag.Parse()

	fmt.Printf("Initialising Files: %s\n", flag.Args()[0])

	checks(cDir, aDir, sDir)

	//Opening files
	f, fErr := os.Open(flag.Args()[0])
	if fErr != nil {
		log.Printf("error: could not open %s to read %v", flag.Args()[0], fErr)
	}
	defer f.Close()

	// Reading in sequences
	var v []seq.Sequence
	r := fasta.NewReader(f, linear.NewSeq("", nil, alphabet.DNA))
	sc := seqio.NewScanner(r)
	for sc.Next() {
		v = append(v, sc.Seq())
	}
	if sc.Error() != nil {
		log.Fatalf("failed to read sequences: %v", sc.Error())
	}
	//Checking that there aren't too many sequences
	if maxFam != 0 && !subSample && len(v) > maxFam {
		log.Fatalf("too many sequences: %d", len(v))
	}

	var aveLength int
	if subSample {
		// Shuffle first.
		w := make([]seq.Sequence, 0, len(v))
		for _, j := range rand.Perm(len(v)) {
			w = append(w, v[j])
		}
		v = w

		// Calculating lengths and averages for all sequences read
		var LenAllSeq = make([]int, len(v))

		for num, i := range v {
			LenAllSeq[num] = i.Len()
		}
		//	fmt.Printf("The variable: %v\n", LenAllSeq)
		totalLength := 0
		for i := 0; i < len(v); i++ {

			totalLength = totalLength + LenAllSeq[i]
		}
		aveLength = totalLength / len(v)
		fmt.Printf("Average length: %v\n", aveLength)
	}

	// FIXME(brittany): Make this more scientifically robust.
	var (
		sampled int
		buf     bytes.Buffer
	)

	// creating a file for the sequence information
	seqFile := fmt.Sprintf("%s_included_sequences.fq", flag.Args()[0])
	seqOut, sErr := os.Create(filepath.Join(aDir, seqFile))
	if sErr != nil {
		log.Fatalf("failed to create %s: %v", seqFile, sErr)
	}
	defer seqOut.Close()
	seqBufOut := bufio.NewWriter(f)
	defer seqBufOut.Flush()

	// printing subsampled sequences to a file
	var (
		LenSubSeq = make([]int, maxFam) // length of each sequence
	)
	for num, s := range v {
		if sampled++; subSample && sampled > maxFam {
			break
		}
		fmt.Fprintf(&buf, "%60a\n", s)
		fmt.Fprintf(seqOut, "including: %s %s\n", s.Name(), s.Description())

		// Calculating lengths and averages for the subsampled sequences
		LenSubSeq[num] = s.Len()
	}
	totalSubLength := 0
	for i := 0; i < maxFam; i++ {
		totalSubLength = totalSubLength + LenSubSeq[i]
	}
	fmt.Printf("total length of subbed: %v\n", totalSubLength)
	aveSubLength := totalSubLength / maxFam
	fmt.Printf("Average length of subbed: %v\n", aveSubLength)
	fmt.Printf("The sub seq variable for %v sequences: %v\n", maxFam, LenSubSeq)

	var (
		c   *linear.QSeq
		m   *multi.Multi
		err error
	)
	//Creating the consensus

	fmt.Println("Creating consensus")
	c, m, err = consensus(&buf)
	if err != nil {
		log.Printf("failed to generate consensus for %s: %v", flag.Args()[0], err)
		return
	}
	c.ID = fmt.Sprintf("%s_consensus", flag.Args()[0])
	c.Desc = fmt.Sprintf("%d members total %v members sampled", len(v), sampled-1)
	c.Threshold = 42
	c.QFilter = seq.CaseFilter
	conLength := c.Len()

	// Find a way to make the consensus the same case

	// Calculating cutoff of consensus length to mean sequence length
	fmt.Printf("Length of consensus:%v\n", conLength)
	cutoffSubs := float64(conLength) / float64(aveLength)
	cutoffTotal := float64(conLength) / float64(aveSubLength)
	fmt.Printf("ratio for all seqs: %f, \nratio for just sub-sampled: %f\n", cutoffTotal, cutoffSubs)

	// Creating a file for the consensus length information
	confile := fmt.Sprintf("%s_consensus-length-%v.txt", flag.Args()[0], maxFam)
	conOut, err := os.Create(filepath.Join(cDir, confile))
	if err != nil {
		log.Fatalf("failed to create %s: %v", confile, err)
	}

	fmt.Fprintf(conOut, "number sampled: %v \nratio for all seqs: %f \nratio for just sub-sampled: %f\n\n %f\t%f", maxFam, cutoffTotal, cutoffSubs, cutoffTotal, cutoffSubs)

	// Creating a file for the consensus
	file := fmt.Sprintf("%s_consensus.fq%v", flag.Args()[0], maxFam)
	out, err := os.Create(filepath.Join(cDir, file))
	if err != nil {
		log.Fatalf("failed to create %s: %v", file, err)
	}
	if consFasta {
		fmt.Fprintf(out, "%60a\n", c)
	} else {
		fmt.Fprintf(out, "%q\n", c)
	}

	// creating a file for the mutliple alignment
	alignFile := fmt.Sprintf("%s_multiple_alignment%v.fq", flag.Args()[0], maxFam)
	AlignOut, err := os.Create(filepath.Join(aDir, alignFile))
	if err != nil {
		log.Fatalf("failed to create %s: %v", alignFile, err)
	}

	if consFasta {
		fmt.Fprintf(AlignOut, "%60a\n", m)
	} else {
		fmt.Fprintf(AlignOut, "%q\n", m)
	}

	out.Close()

	fmt.Printf("Complete\n\n")
}