vg
1.61.0
Grafik variasi memberikan pengkodean ringkas dari sekuens banyak genom. Grafik variasi (khususnya seperti yang diimplementasikan dalam VG) terdiri dari:
Model ini mirip dengan grafik urutan yang telah digunakan dalam perakitan dan perataan urutan beberapa.
Jalur menyediakan sistem koordinat relatif terhadap genom yang dikodekan dalam grafik, memungkinkan pemetaan stabil untuk diproduksi bahkan jika struktur grafik diubah. Model grafik variasi membuat embedding ini eksplisit dan esensial. Alat dalam VG mempertahankan jalur sebagai tidak berubah selama transformasi grafik. Mereka menggunakan jalur untuk memproyeksikan data relatif grafik ke ruang koordinat-relatif referensi. Paths memberikan koordinat yang stabil untuk grafik yang dibangun dengan cara yang berbeda dari urutan input yang sama.
Tolong kutip:
vgvg giraffevg callvg deconstructvg snarlsvg haplotypes dan/atau vg giraffe --haplotype-name Kami memelihara forum dukungan di Biostars: https://www.biostars.org/tag/vg/
Cara termudah untuk mendapatkan VG adalah dengan mengunduh salah satu rilis Builds kami untuk Linux. Kami memiliki irama rilis 6 minggu, jadi bangunan kami tidak pernah terlalu ketinggalan zaman.
Unduh rilis VG terbaru untuk Linux
Untuk MacOS , lihat Building on MacOS.
Jika Anda tidak ingin atau tidak dapat menggunakan pelepasan VG yang sudah dibangun, atau jika Anda ingin menjadi pengembang VG, Anda dapat membangunnya dari sumber.
Pertama, dapatkan repo dan submodulnya:
git clone --recursive https://github.com/vgteam/vg.git
cd vg
Kemudian, instal dependensi VG. Anda akan membutuhkan perpustakaan pengembangan protobuf dan jansson yang diinstal, dan untuk menjalankan tes yang Anda perlukan:
jq , bc , rs , dan parallelhexdump dan column dari bsdmainutilsnpm untuk menguji contoh dokumentasi).Di Ubuntu, Anda harus dapat melakukan:
make get-deps
Jika Anda mendapatkan keluhan bahwa sudo tidak ditemukan, instal:
apt update
apt install sudo
Jika Anda mendapatkan banyak kesalahan seperti E: Unable to locate package build-essential , pastikan file indeks paket Anda mutakhir dengan menjalankan:
sudo apt update
Pada distro lain, atau jika Anda tidak memiliki akses root, Anda harus melakukan yang setara dengan:
sudo apt-get install build-essential git cmake pkg-config libncurses-dev libbz2-dev
protobuf-compiler libprotoc-dev libprotobuf-dev libjansson-dev
automake gettext autopoint libtool jq bsdmainutils bc rs parallel
npm curl unzip redland-utils librdf-dev bison flex gawk lzma-dev
liblzma-dev liblz4-dev libffi-dev libcairo-dev libboost-all-dev
libzstd-dev pybind11-dev python3-pybind11
Perhatikan bahwa Ubuntu 16.04 tidak mengirimkan protobuf yang cukup baru; VG membutuhkan protobuf 3 yang harus dipasang secara manual.
Saat ini, Anda akan membutuhkan GCC versi 4.9 atau lebih, dengan dukungan untuk C ++ 14, untuk mengkompilasi VG. (Periksa versi Anda dengan gcc --version .) GCC hingga 11.2.0 didukung.
Perpustakaan lain mungkin diperlukan. Harap laporkan kesulitan membangun.
Perhatikan bahwa diperlukan OS 64-bit. Ubuntu 20.04 harus bekerja.
Saat Anda siap, bangun dengan make . Anda dapat menggunakan make -j16 untuk menjalankan 16 Build Thread sekaligus, yang sangat mempercepat prosesnya. Jika Anda memiliki lebih banyak core CPU, Anda dapat menggunakan angka yang lebih tinggi.
Perhatikan bahwa VG dapat memakan waktu di mana saja dari 10 menit hingga lebih dari satu jam untuk dikompilasi tergantung pada mesin Anda dan jumlah utas yang digunakan.
Anda juga dapat menghasilkan biner statis dengan make static , dengan asumsi Anda memiliki versi statis dari semua dependensi yang dipasang pada sistem Anda.
Setelah VG dibangun, biner akan berada di bin/vg di dalam direktori repositori VG. Anda dapat menjalankannya dengan:
./bin/vg
Anda juga dapat menambahkan direktori ke variabel lingkungan PATH Anda, sehingga Anda dapat meminta vg dari direktori mana pun. Untuk melakukan itu pada bash, gunakan perintah ini dari direktori repositori VG:
echo 'export PATH="${PATH}:'"$(pwd)"'/bin"' >>~/.bashrc
Kemudian tutup terminal Anda dan buka yang baru. Jalankan vg untuk memastikan itu berhasil.
Jika tidak berhasil, pastikan Anda memiliki file .bash_profile di direktori home Anda yang akan menjalankan .bashrc Anda:
if [ -f ~/.bashrc ]; then
source ~/.bashrc
fi
Langkah pertama adalah mengkloning repositori VG:
git clone --recursive https://github.com/vgteam/vg.git
cd vg
VG tergantung pada sejumlah paket yang diinstal pada sistem tempat ia sedang dibangun. Dependensi dapat diinstal menggunakan MacPorts atau Homebrew.
Anda dapat menggunakan MacPorts untuk menginstal dependensi VG:
sudo port install libtool protobuf3-cpp jansson jq cmake pkgconfig autoconf automake libtool coreutils samtools redland bison gperftools md5sha1sum rasqal gmake autogen cairo libomp boost zstd pybind11
Homebrew menyediakan solusi manajemen paket lain untuk OSX, dan mungkin lebih disukai daripada beberapa pengguna daripada MacPorts. VG mengirimkan Brewfile yang menggambarkan dependensi homebrewnya, jadi dari direktori root VG, Anda dapat memasang dependensi, dan mengeksposnya ke VG, seperti ini:
# Install all the dependencies in the Brewfile
brew bundle
Dengan dependensi terpasang, VG sekarang dapat dibangun:
make
Seperti halnya Linux, Anda dapat menambahkan -j16 atau nomor lain di akhir untuk menjalankan beberapa tugas build sekaligus, jika komputer Anda dapat menanganinya.
Perhatikan bahwa binari statis belum dapat dibangun untuk Mac.
VG Mac Build menargetkan apa pun versi saat ini dari Apple Clang, dan versi apa pun dari Apple Clang disediakan oleh Github Action Mac CI System kami. Jika dentang Anda terkini dan VG tidak membangun untuk Anda, buka masalah.
Setelah VG dibangun, biner akan berada di bin/vg di dalam direktori repositori VG. Anda dapat menjalankannya dengan:
./bin/vg
Anda juga dapat menambahkan direktori ke variabel lingkungan PATH Anda, sehingga Anda dapat meminta vg dari direktori mana pun. Untuk melakukannya pada shell zsh mac default, gunakan perintah ini dari direktori repositori vg:
echo 'export PATH="${PATH}:'"$(pwd)"'/bin"' >>~/.zshrc
Kemudian tutup terminal Anda dan buka yang baru. Jalankan vg untuk memastikan itu berhasil.
Platform MAC bergerak ke lengan, dengan Apple's M1, M1 Pro, M1 Max, dan desain chip berikutnya. Basis kode VG mendukung ARM di Mac serta di Linux. Instruksi instalasi normal bekerja pada lengan lengan pabrik-segar .
Namun, mudah untuk mengalami masalah ketika memigrasi lingkungan pembangunan VG yang berfungsi atau memigrasi macports atau homebrew dari x86_64 ke lengan. Mesin ARM dapat berhasil menjalankan alat x86_64 yang diinstal melalui MacPorts atau homebrew di mesin lama, tetapi VG hanya dapat dibangun dengan benar di lengan jika Anda menggunakan versi ARM dari alat build, seperti make dan Cmake.
Jadi, setelah bermigrasi ke lengan Mac menggunakan alat migrasi misalnya:
make clean . Ini harus menghapus semua artefak build.make . Jika Anda masih mengalami masalah membangun setelah ini, hapus seluruh checkout dan periksa lagi kode; make clean tidak di bawah uji CI dan tidak selalu terkini dengan sisa sistem pembangunan.
Apakah itu membantu atau tidak, silakan buka masalah sehingga kami dapat membantu memperbaiki atau memperbaiki make clean .
Catatan Lihat contoh
vg autoindexdi bawah ini untuk cara menggunakan alat itu sebagai penggantivg constructuntuk membangun dan mengindeks grafik dalam satu langkah.
Salah satu cara untuk membangun grafik dengan vg adalah dengan construct dari panggilan varian menggunakan file Referensi FASTA dan file VCF. Jika Anda bekerja di test/ Direktori VG:
vg construct -r small/x.fa -v small/x.vcf.gz > x.vg Perhatikan bahwa untuk membangun grafik, indeks file VCF diperlukan. File indeks VCF dapat dihasilkan menggunakan perintah tabix yang disediakan oleh SamTools (misalnya tabix -p vcf x.vcf.gz pada baris perintah).
Anda juga dapat membangun grafik (dan indeks untuk pemetaan dengan VG) dari satu set rakitan genom (FASTA), yang bertentangan dengan panggilan varian seperti dijelaskan di atas, menggunakan minigraf-kalkus.
vg mendukung banyak format, tiga yang paling penting adalah:
PackedGraph (.vg) : Ini adalah format asli vg's . Ini mendukung suntingan dari semua jenis (ke topologi dan jalur), tetapi bisa tidak efisien pada skala besar, terutama dengan banyak jalur.GFA (.gfa) : GFA adalah format berbasis teks standar dan biasanya cara terbaik untuk bertukar grafik antara vg dan alat pangenome lainnya. vg juga dapat beroperasi pada file GFA ( tidak terkompresi ) secara langsung, dengan cara menggunakan representasi PackedGraph dalam memori (dan karenanya berbagi masalah penskalaan format dan pengeditan-kemampuan).GBZ (.gbz) : GBZ adalah format yang sangat terkompresi yang menggunakan lebih sedikit ruang untuk menyimpan jalur daripada format di atas, tetapi dengan biaya tidak memungkinkan pengeditan umum ke grafik. Anda dapat menanyakan format grafik apa pun menggunakan vg stats -F .
Secara umum, Anda akan membangun dan mengindeks grafik vg menggunakan vg autoindex (dari GFA atau VCF) atau Minigraph-Cactus (FASTA). Anda juga dapat mengimpor file GFA dari alat lain seperti ODGI dan PGGB menggunakan vg convert -g .
Anda dapat mengonversi grafik apa pun ke GFA menggunakan vg convert -f . Secara default, vg menggunakan GFA v1.1 di mana jalur direpresentasikan sebagai w-lines. Untuk menggunakan p -lines sebagai gantinya (GFA V1.0), gunakan vg convert -fW .
Format GBZ membuat perbedaan antara jalur REFERENCE dan HAPLOTYPE . Jalur REFERENCE dapat digunakan sebagai sistem koordinat tetapi lebih mahal untuk disimpan. Jalur HAPLOTYPE sangat terkompresi tetapi tidak dapat digunakan untuk pencarian posisi. Dalam grafik HPRC misalnya, contigs dari GRCh38 dan CHM13(T2T) adalah jalur REFERENCE dan semua sampel lain jalur HAPLOTYPE .
Perbedaan antara jalur REFERENCE dan HAPLOTYPE dibawa ke dalam format lain seperti .vg dan .gfa untuk memfasilitasi konversi dan antar operasi. Dalam .gfa , jalur REFERENCE adalah p-lines, atau w-lines yang nama sampelnya ditandai di header. W-lines yang namanya tidak ditandai di header adalah jalur HAPLOTYPE . Dalam .vg mereka dilambangkan menggunakan konvensi penamaan.
Lihat Path Metadata Wiki untuk lebih jelasnya.
PERINGATAN
GBZadalah satu -satunya format yang mendukung pemuatan jalurHAPLOTYPEyang efisien dalamvg. Anda dapat mengalami masalah yang mencoba memuat grafik seluruh genom dengan ribuanHAPLOTYPEdari file.vgatau.gfa.vg convert -Hdapat digunakan untuk menjatuhkan jalurHAPLOTYPE, memungkinkan grafik lebih mudah dimuat dalam format lain.
Perhatikan yang terbaik adalah menggunakan alat
vg convertyang lebih baru (dijelaskan di atas) untuk konversi GFA
vg view menyediakan cara untuk mengubah grafik menjadi berbagai format:
# GFA output
vg view x.vg > x.gfa
# dot output suitable for graphviz
vg view -d x.vg > x.dot
# And if you have a GAM file
cp small/x-s1337-n1.gam x.gam
# json version of binary alignments
vg view -a x.gam > x.jsonJika Anda memiliki lebih dari satu urutan, atau Anda sedang mengerjakan grafik besar, Anda ingin memetakan daripada hanya menyelaraskan.
Ada beberapa pemetaan baca di vg :
vg giraffe dirancang untuk menjadi cepat untuk bacaan pendek yang sangat akurat, terhadap grafik dengan informasi haplotype.vg map adalah mapper baca tujuan umum.vg mpmap melakukan pemetaan "multi-jalur", untuk memungkinkan menggambarkan ketidakpastian penyelarasan lokal. Ini berguna untuk transkriptomik. vg giraffe Untuk menggunakan vg giraffe untuk memetakan bacaan, pertama -tama Anda harus menyiapkan indeks. Ini paling baik dilakukan dengan menggunakan vg autoindex . Untuk mendapatkan vg autoindex menggunakan informasi haplotype dari file VCF, Anda dapat memberikannya VCF dan referensi linier terkait secara langsung.
# construct the graph and indexes (paths below assume running from `vg/test` directory)
vg autoindex --workflow giraffe -r small/x.fa -v small/x.vcf.gz -p x
# simulate a bunch of 150bp reads from the graph, into a GAM file of reads aligned to a graph
vg sim -n 1000 -l 150 -x x.giraffe.gbz -a > x.sim.gam
# now re-map these reads against the graph, and get BAM output in linear space
# FASTQ input uses -f instead of -G.
vg giraffe -Z x.giraffe.gbz -G x.sim.gam -o BAM > aln.bam Informasi lebih lanjut tentang penggunaan vg girafe dapat ditemukan di vg Wiki.
vg map Jika grafik Anda besar, Anda ingin menggunakan vg index untuk menyimpan grafik dan vg map untuk menyelaraskan bacaan. vg map mengimplementasikan benih berbasis KMER dan memperluas model penyelarasan yang mirip dengan yang digunakan dalam pelurus seperti Novoalign atau Mosaik. Pertama, indeks on-disk dibangun dengan vg index yang mencakup grafik itu sendiri dan kmers dengan ukuran tertentu. Saat pemetaan, ukuran KMER apa pun lebih pendek dari yang digunakan dalam indeks dapat digunakan, dan secara default mapper akan mengurangi ukuran KMER untuk meningkatkan sensitivitas ketika penyelarasan pada k tertentu gagal.
# construct the graph (paths below assume running from `vg/test` directory)
vg construct -r small/x.fa -v small/x.vcf.gz > x.vg
# store the graph in the xg/gcsa index pair
vg index -x x.xg -g x.gcsa -k 16 x.vg
# align a read to the indexed version of the graph
# note that the graph file is not opened, but x.vg.index is assumed
vg map -s CTACTGACAGCAGAAGTTTGCTGTGAAGATTAAATTAGGTGATGCTTG -x x.xg -g x.gcsa > read.gam
# simulate a bunch of 150bp reads from the graph, one per line
vg sim -n 1000 -l 150 -x x.xg > x.sim.txt
# now map these reads against the graph to get a GAM
vg map -T x.sim.txt -x x.xg -g x.gcsa > aln.gam
# surject the alignments back into the reference space of sequence "x", yielding a BAM file
vg surject -x x.xg -b aln.gam > aln.bam
# or alternatively, surject them to BAM in the call to map
vg sim -n 1000 -l 150 -x x.xg > x.sim.txt
vg map -T x.sim.txt -x x.xg -g x.gcsa --surject-to bam > aln.bamVariasi dari keberpihakan dapat disematkan kembali ke dalam grafik. Proses ini disebut augmentasi dan dapat digunakan untuk panggilan varian de novo , misalnya (lihat di bawah).
Peringatan menggunakan
vg augmentuntuk panggilan varian tetap sangat eksperimental. Sama sekali tidak disarankan untuk panggilan varian struktural, dan bahkan untuk varian kecil, Anda akan sering mendapatkan hasil yang jauh lebih akurat (setidaknya pada manusia) dengan memproyeksikan penyelarasan Anda keBAMdan menjalankan penelepon varian linier seperti DeepVariant.
# augment the graph with all variation from the GAM except that implied by soft clips, saving to aug.vg. aug.gam contains the same reads as aln.gam but mapped to aug.vg
vg augment x.vg aln.gam -A aug.gam > aug.vg
# augment the graph with all variation from the GAM, saving each mapping as a path in the graph.
# softclips of alignment paths are preserved (`-S`).
# Note, this can be much less efficient than the above example if there are many alignments in the GAM
vg augment x.vg aln.gam -i -S > aug_with_paths.vgPerhatikan informasi lebih lanjut dapat ditemukan di wiki.
Contoh -contoh berikut menunjukkan cara menghasilkan VCF dengan VG menggunakan dukungan baca. Mereka bergantung pada output dari contoh pemetaan dan augmentasi di atas. Varian kecil dan SV dapat dipanggil menggunakan pendekatan yang sama. Saat ini, lebih akurat untuk SVS .
Hubungi hanya varian yang ada dalam grafik:
# Compute the read support from the gam
# -Q 5: ignore mapping and base qualitiy < 5
vg pack -x x.xg -g aln.gam -Q 5 -o aln.pack
# Generate a VCF from the support.
vg call x.xg -k aln.pack > graph_calls.vcf Secara default, vg call menghilangkan varian 0/0 dan mencoba menormalkan alel untuk membuat VCF lebih kompak. Kedua langkah ini dapat menyulitkan untuk membandingkan output dari sampel yang berbeda karena VCF akan memiliki koordinat yang berbeda meskipun mereka dibuat menggunakan grafik yang sama. Opsi -a membahas hal ini dengan menelepon setiap geraman menggunakan koordinat yang sama dan termasuk panggilan referensi. Output untuk sampel yang berbeda dapat dikombinasikan dengan bcftools merge -m all .
vg call x.xg -k aln.pack -a > snarl_genotypes.vcf
Untuk juga mempertimbangkan varian baru dari bacaan, gunakan grafik augmented dan gam (seperti yang dibuat dalam contoh "augmentation" menggunakan vg augment -A ):
Peringatan menggunakan
vg augmentuntuk panggilan varian tetap sangat eksperimental. Sama sekali tidak disarankan untuk panggilan varian struktural, dan bahkan untuk varian kecil, Anda akan sering mendapatkan hasil yang jauh lebih akurat (setidaknya pada manusia) dengan memproyeksikan penyelarasan Anda keBAMdan menjalankan penelepon varian linier seperti DeepVariant.
# Index our augmented graph
vg index aug.vg -x aug.xg
# Compute the read support from the augmented gam (ignoring qualitiy < 5, and 1st and last 5bp of each read)
vg pack -x aug.xg -g aug.gam -Q 5 -s 5 -o aln_aug.pack
# Generate a VCF from the support
vg call aug.xg -k aln_aug.pack > calls.vcf Proses serupa dapat dengan digunakan untuk genotipe varian yang diketahui dari VCF. Untuk melakukan ini, grafik harus dibangun dari VCF dengan vg construct -a (grafik dari sumber lain seperti vg autoindex dan Minigraph-Cactus tidak dapat digunakan):
# Re-construct the same graph as before but with `-a`
vg construct -r small/x.fa -v small/x.vcf.gz -a > xa.vg
# Index the graph with `-L' to preserve alt paths in the xg
vg index xa.vg -x xa.xg -L
# Compute the support (we could also reuse aln.pack from above)
vg pack -x xa.xg -g aln.gam -o aln.pack
# Genotype the VCF (use -v)
vg call xa.xg -k aln.pack -v small/x.vcf.gz > genotypes.vcfPre-filtering GAM sebelum komputasi dukungan dapat meningkatkan ketepatan panggilan SNP:
# filter secondary and ambiguous read mappings out of the gam
vg filter aln.gam -r 0.90 -fu -m 1 -q 15 -D 999 -x x.xg > aln.filtered.gam
# then compute the support from aln.filtered.gam instead of aln.gam in above etc.
vg pack -x xa.xg -g aln.filtered.gam -o aln.pack
vg call xa.xg -k aln.pack -v small/x.vcf.gz > genotypes.vcfUntuk grafik yang lebih besar, disarankan untuk menghitung Snarl secara terpisah:
vg snarls x.xg > x.snarls
# load snarls from a file instead of computing on the fly
vg call x.xg -k aln.pack -r x.snarls > calls.vcf CATATAN: vg augment , vg pack , vg call dan vg snarls sekarang semuanya dapat dijalankan langsung pada format grafik apa pun (ex '.gbz', '.gfa', .vg , .xg (kecuali augment ) atau apapun dengan vg convert ). Beroperasi pada .vg atau '.gfa' menggunakan memori terbanyak dan tidak direkomendasikan untuk grafik besar. Output dari vg pack hanya dapat dibaca bersama dengan grafik yang sama yang digunakan untuk membuatnya, jadi vg pack x.vg -g aln.gam -o x.pack lalu vg call x.xg -k x.pack tidak akan berfungsi .
Varian menyimpulkan dari penyelarasan yang tersirat oleh jalur dalam grafik. Ini dapat digunakan, misalnya, untuk memanggil SV langsung dari grafik variasi yang dibangun dari beberapa perataan rakitan yang berbeda:
# create a graph from a multiple alignment of HLA haplotypes (from vg/test directory)
vg msga -f GRCh38_alts/FASTA/HLA/V-352962.fa -t 1 -k 16 | vg mod -U 10 - | vg mod -c - > hla.vg
# index it
vg index hla.vg -x hla.xg
# generate a VCF using gi|568815592:29791752-29792749 as the reference contig. The other paths will be considered as haploid samples
vg deconstruct hla.xg -e -p " gi|568815592:29791752-29792749 " > hla_variants.vcf Haplotype jalur dari .gbz atau .gbwt indeks input dapat dipertimbangkan menggunakan -z dan `-g ', masing -masing.
Seperti halnya vg call , yang terbaik adalah menghitung Snarl secara terpisah dan meneruskannya dengan -r saat bekerja dengan grafik besar.
vg memiliki sejumlah alat untuk mendukung analisis transkriptomik dengan grafik yang disambung (yaitu grafik yang memiliki persimpangan splice beranotasi ditambahkan sebagai tepi ke dalam grafik). Tepi ini dapat ditambahkan ke dalam grafik yang ada menggunakan vg rna . Kami kemudian dapat melakukan pemetaan sadar-splice ke grafik ini menggunakan vg mpmap . Pengembang vg juga telah membuat alat untuk kuantifikasi transkrip haplotipe-sadar berdasarkan alat ini di rpvg . Cara termudah untuk memulai pipa ini adalah dengan menggunakan subkomand vg autoindex untuk membuat indeks untuk vg mpmap . vg autoindex membuat indeks untuk pemetaan dari format pertukaran umum seperti FASTA, VCF, dan GTF.
Informasi lebih lanjut tersedia di halaman Wiki tentang transkriptomik.
Bekerja dari test/ Direktori Contoh berikut menunjukkan cara membuat grafik pangenome yang disambung dan indeks menggunakan vg autoindex dengan 4 utas:
# Create spliced pangenome graph and indexes for vg mpmap
vg autoindex --workflow mpmap -t 4 --prefix vg_rna --ref-fasta small/x.fa --vcf small/x.vcf.gz --tx-gff small/x.gtf Baca RNA-Seq dapat dipetakan ke grafik pangenome yang disambung menggunakan vg mpmap dengan 4 utas:
# Map simulated RNA-seq reads using vg mpmap
vg mpmap -n rna -t 4 -x vg_rna.spliced.xg -g vg_rna.spliced.gcsa -d vg_rna.spliced.dist -f small/x_rna_1.fq -f small/x_rna_2.fq > mpmap.gamp Ini akan menghasilkan keberpihakan dalam format multipath. Untuk informasi lebih lanjut tentang format Alignment Multipath dan vg mpmap lihat halaman Wiki di MPMAP. Menjalankan dua perintah pada data contoh kecil menggunakan 4 utas harus pada sebagian besar mesin membutuhkan waktu kurang dari satu menit.
Jika Anda memiliki grafik kecil, Anda dapat menyelaraskan urutan ke seluruh grafik, menggunakan penyelarasan urutan parsial panjang penuh:
vg align -s CTACTGACAGCAGAAGTTTGCTGTGAAGATTAAATTAGGTGATGCTTG x.vgPerhatikan bahwa Anda tidak perlu menyimpan grafik pada disk sama sekali, Anda bisa menyalakannya ke pelurus lokal:
vg construct -r small/x.fa -v small/x.vcf.gz | vg align -s CTACTGACAGCAGAAGTTTGCTGTGAAGATTAAATTAGGTGATGCTTG - Sebagian besar perintah memungkinkan streaming grafik masuk dan keluar dari vg .
Berbagai perintah tersedia:
vg adalah kumpulan alat berdasarkan model data umum (grafik variasi) yang dijelaskan oleh skema protobuf (vg.proto). Objek data yang ditentukan dalam VG.Proto dapat diserialisasi melalui pola aliran yang ditentukan dalam stream.hpp. Tidak perlu menulis kode dalam VG untuk berinteraksi dengan algoritma yang ditentukan di sini. Sebaliknya, kadang -kadang lebih sederhana untuk menulis algoritma eksternal yang membaca dan menulis format data yang sama.
Mit
