Skip to main content
SimilarExport ZIP
100%

Gist 454d4384d1fd704c8d1933b01d2c2af4

✓ Published0🌍 Public
NNpfn
Last edited Feb 8, 2019
Created on Feb 8, 2019

This example shows a batch processing workflow for sequencing alignment files, automating the conversion of SAM files into sorted, indexed BAM files. The shell script iterates over a list of run identifiers, using the `samtools view` command to filter out unmapped reads with the `-F 4` flag, then pipes the output to `samtools sort` to create order-preserved BAM output. Each resulting file is indexed with `samtools index` for downstream genomic analysis. The script operates within a directory structure defined by the `$TPRESEQ` environment variable.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist d5a955d9a667be4ff4afe7064affbb31

This example demonstrates a bioinformatics mapping workflow for processing sequencing reads. The shell script uses the BWA alignment tool to map trimmed FASTQ files from multiple clones against a reference genome (NC_012967.fas). It first indexes the reference with `bwa index`, then iterates through a list of runs from `fastq/list_run`, performing alignment with `bwa aln` using four threads and converting the results to SAM format with `bwa samse` while adding read-group metadata via the `-r` flag. The script outputs aligned SAM files into the `mapping` directory.

NNpfn
78% match
Loading thumbnail…

Gist aa8c974207019f98e6d45a49488b2c4b

This visualization shows the process of generating pileup files from sequenced reads for a set of 29 samples. The Bash script iterates through a list of sample identifiers, using the `samtools mpileup` command to produce alignment summaries for each sample against a reference genome. The script relies on the command-line APIs of `samtools` for pileup generation, operating on sorted BAM files. The output from this script would be a text-based pileup format, which is not a graphical visualization but a data-preparation step for subsequent analysis. The code references a reference file and a list of SRR accession numbers, indicating the source is genomic sequencing data.

NNpfn
75% match
Loading thumbnail…

Gist ac0e4a9bdb2f03d365c4402d04ecba09

This example shows a command-line workflow for detecting genetic variants from sequencing reads mapped to a reference genome. It first uses `samtools mpileup` to generate a binary call format (BCF) file, then `bcftools call` to produce a VCF file of variants. A second, independent variant call is made using `freebayes` with a ploidy setting of one, outputting its own VCF. The script processes all sorted BAM files in a mapping directory, using the NC_012967.fas reference, demonstrating two standard variant-calling pipelines for haploid samples.

NNpfn
71% match
Loading thumbnail…

Gist b503b3f905281f7da44c76ba5ed1d8d9

This example demonstrates a Bash script that trims raw FASTQ sequencing reads using the `fastq-mcf` tool from the ea-utils package. It shows how to process multiple paired-end files in a batch, reading a list of sample identifiers from `fastq/list_run` and applying a quality cutoff of Q20. The script iterates over each sample, takes the forward read file (`${i}_1.fastq.gz`), and generates a trimmed output file (`${i}_1_trim.fastq`) in the same directory. Adapter sequences are specified in `$TPDIR/misc/adap_illumina.fas`, and the output is written to the project’s fastq folder.

NNpfn
66% match
Loading thumbnail…

Gist 9a3defa4596db38a11fc0ec9549b4834

This example demonstrates a preprocessing workflow for raw paired-end Illumina sequencing data. It shows the trimming of low-quality bases and removal of adapter sequences using the `fastq-mcf` tool from the ea-utils suite, followed by quality control reporting with `FastQC`. The script runs `fastq-mcf` with parameters for a minimum quality score of 20, a mean quality threshold, and a 150-base pair read length, producing trimmed FASTQ files. These outputs are then processed by `FastQC` to generate quality assessment reports for both the forward and reverse reads, illustrating a standard bioinformatics pipeline for high-throughput sequence data preparation.

NNpfn
64% match
Loading thumbnail…

Gist 3d7c2ec8630fd8451ee2b2ed513c2c4a

This example documents the assembly of a microbial genome from paired-end Illumina sequencing data. It shows the command-line workflow that converts raw FASTQ files to FASTA format and then performs a de novo assembly using the IDBA-UD software. The script demonstrates the use of the `fq2fa` utility to merge and convert paired reads, followed by an `idba_ud` assembly run with a single thread. The final assembly output is moved to a dedicated directory for further analysis, illustrating a typical bioinformatics pipeline for genomic sequence reconstruction.

NNpfn
61% match
Loading thumbnail…

Gist e3718d6464d2ba18e5a08233edd0aeb1

This Perl script splits a multi-sequence FASTA file into individual FASTA files, one per sequence. It reads the input file line by line, opens a new output file whenever a header line starting with `>` is encountered, and writes the header and subsequent sequence lines to that file. The code uses the `open`, `close`, and `shift` built-in functions to manage up to 248 output files named `CEG0.fasta` through `CEG247.fasta`. The script demonstrates a simple file-parsing and output-splitting workflow for bioinformatics sequence data.

NNpfn
61% match
Loading thumbnail…

Gist 6cde24482216f46654efb9e0cef0f166

This example shows a Unix shell script for assembling and evaluating MinION nanopore sequencing data. It configures environment variables for Java, Perl, and the Canu assembler, then runs Canu with parameters for a 10kb genome, specifying an error rate and corrected nanopore reads as input. The script uses the `assembly-stats` tool to generate statistics for the resulting contigs and unassembled sequences, printing summary metrics to the console. The code relies on the Canu command-line interface, the `assembly-stats` binary, and shell environment exports for dependency management.

NNpfn
60% match