add sequencing functions

[Koeng101]

This PR adds some functions for handling / analyzing DNA sequencing.

[Koeng101]

Channels should be passing values, not pointers. This needs to be fixed.

[Koeng101]

Things to do:

• [x] Make all concurrent functions implement context closing
• [x] Replace all channel operations with values instead of pointers
• [x] Update non-err functions with nil return for consistent styling
• [x] Make generic function for workflows (RunWorkflow) which takes in the errorGroup functions and the number of workers for each
• [x] Fix the damn linter

[Koeng101]

func TrimBarcodeWithChannels(barcodeName string, fastqInput <-chan fastq.Read, fastqOutput chan<- fastq.Read) error {
    for {
        select {
        case data, ok := <-fastqInput:
            if !ok {
                // If the input channel is closed, we close the output channel and return
                close(fastqOutput)
                return nil
            }
            trimmedRead, err := TrimBarcode(barcodeName, *data)
            if err != nil {
                close(fastqOutput)
                return err
            }
            fastqOutput <- &trimmedRead
        }
    }

}

// TrimBarcode takes a barcodeName and a fastqSequence and returns a trimmed
// barcode.
func TrimBarcode(barcodeName string, fastqRead fastq.Read) (fastq.Read, error) {
    // Copy into new fastq read
    var newFastqRead fastq.Read
    newFastqRead.Identifier = fastqRead.Identifier
    newFastqRead.Optionals = make(map[string]string)
    for key, value := range fastqRead.Optionals {
        newFastqRead.Optionals[key] = value
    }

    // Get the barcode
    barcode, ok := NativeBarcodeMap[barcodeName]
    if !ok {
        return newFastqRead, fmt.Errorf("barcode %s not found in NativeBarcodeMap.", barcodeName)
    }

    // Trim in the forward direction
    var sequence string
    var quality string
    sequence = fastqRead.Sequence
    quality = fastqRead.Quality
    if len(sequence) > 80 {
        score, alignment, err := Align(sequence[:80], barcode.Forward)
        if err != nil {
            return newFastqRead, err
        }
        // Empirically from looking around, it seems to me that approximately a
        // score of 21 looks like a barcode match. This is almost by definition a
        // magic number, so it is defined above as so.
        if score >= ScoreMagicNumber {
            modifiedAlignment := strings.ReplaceAll(alignment, "-", "")
            index := strings.Index(sequence, modifiedAlignment)
            // The index needs to be within the first 80 base pairs. Usually the
            // native adapter + native barcode is within the first ~70 bp, but we
            // put a small buffer.
            if index != -1 {
                // 7 here is a magic number between the native barcode and your
                // target sequence. It's just a number that exists irl, so it is
                // not defined above.
                newStart := index + 7
                if newStart < len(sequence) {
                    sequence = sequence[newStart:]
                    quality = quality[newStart:]
                }
            }
        }
    }

    // Now do the same thing with the reverse strand.
    if len(sequence) > 80 {
        score, alignment, err := Align(sequence[len(sequence)-80:], barcode.Reverse)
        if err != nil {
            return newFastqRead, err
        }
        if score >= ScoreMagicNumber {
            modifiedAlignment := strings.ReplaceAll(alignment, "-", "")
            index := strings.Index(sequence, modifiedAlignment)
            // This time we need to check within the last 80 base pairs.
            if index != -1 {
                newEnd := index - 7
                if newEnd < len(sequence) {
                    sequence = sequence[:newEnd]
                    quality = quality[:newEnd]
                }
            }
        }
    }
    newFastqRead.Sequence = sequence
    newFastqRead.Quality = quality
    return newFastqRead, nil
}

// Align uses the SmithWaterman algorithm to align a barcode to a sequence.
// It is used because it is a rather simple algorithm, and since barcodes are
// sufficiently small, fast enough.
func Align(sequence string, barcodeSequence string) (int, string, error) {
    m := [][]int{
        /*       A C G T U */
        /* A */ {1, -1, -1, -1, -1},
        /* C */ {-1, 1, -1, -1, -1},
        /* G */ {-1, -1, 1, -1, -1},
        /* T */ {-1, -1, -1, 1, -1},
        /* U */ {-1, -1, -1, -1, 1},
    }

    alphabet := alphabet.NewAlphabet([]string{"A", "C", "G", "T", "U"})
    subMatrix, err := matrix.NewSubstitutionMatrix(alphabet, alphabet, m)
    if err != nil {
        return 0, "", err
    }
    scoring, err := align.NewScoring(subMatrix, -1)
    if err != nil {
        return 0, "", err
    }
    score, alignSequence, _, err := align.SmithWaterman(sequence, barcodeSequence, scoring)
    if err != nil {
        return 0, "", err
    }
    return score, alignSequence, nil
}

I don't think I need trim barcodes right now, with megamash now being a thing. So I'm deleting this block of code, but want to maintain it here for posterity.

[Koeng101]

Mostly, I just want to add docs for megamash, then this is ready.