基因组测序模拟

杨利霞

基因组测序模拟
基因组测序模拟

一、摘要

通过熟悉已有的基因组测序模拟和评估程序，加深全基因组鸟枪法测序原理的理解，并且能够编写程序模拟全基因组鸟枪法测序，理解覆盖度、测序深度、拷贝数等概念，设置测序相关参数，生成单端/双端测序结果文件
7 W! d' N/ T0 f$ @# {3 P: G1 H
. y: Z& N8 x) X, U, a! h二、材料和方法
( Z2 o  W1 N. r5 I
1、硬件平台
# [( U7 u  H: i( @3 A3 p
: L% V: {% }7 o3 z6 N8 \: \处理器:Intel（R） Core（TM）i7-4710MQ CPU @ 2.50GHz
安装内存(RAM)：16.0GB

0 ~& w& o5 ]9 ^3 y1 g2、系统平台
: M* t/ k0 Q# E6 g) A0 P2 R# u7 N2 rWindows 8.1，Ubuntu
  {0 G2 |8 p2 c1 x  ~$ ^8 J! k- R
3、软件平台

art_454
GenomeABC http://crdd.osdd.net/raghava/genomeabc/
Python3.5
Biopython
4、数据库资源

NCBI数据库：https://www.ncbi.nlm.nih.gov/

5 O6 N9 L7 Z2 Y. I4 c- v5、研究对象
) R2 d" r0 P6 W, g
  }4 T/ f9 j, Z0 ^5 o2 c% d. y酵母基因组Saccharomyces cerevisiae S288c (assembly R64)
4 Q$ f+ m4 U" c6 k0 j2 V0 `ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCF/000/146/045/GCF_000146045.2_R64/GCF_000146045.2_R64_genomic.fna.gz

6、方法

8 H# s$ \& s4 t& [- K% |art_454的使用
首先至art系列软件的官网，下载软件，在ubuntu系统安装，然后阅读相关参数设置的帮助文档，运行程序。
GenomeABC
( k5 H$ e) `0 ~; e0 \4 G进入GenomeABC(http://crdd.osdd.net/raghava/genomeabc/)，输入参数，获得模拟测序结果。
编程模拟测序
! v8 ~& u& g+ J下载安装python，并且安装biopython扩展模块，编写程序，模拟单端/双端测序。
! I/ E1 O% }) D三、结果

1、art_454的运行结果

无参数art_454运行，阅读帮助文档
. j4 q: E5 z) l5 S
图表 1无参数art_454运行
对酵母基因组进行基因组单端测序模拟，FOLD_COVERAGE设为20，即覆盖度为20.
$ e. g2 M4 w/ b: ?1 Y. L+ N) n/ U( N0 F下图为模拟单端测序，程序运行过程及结果

图表 2 art454单端测序

+ d" C. H+ R; B$ K/ v5 m# o图表 3 art454单端模拟结果
  q# x/ G9 j" c% ^- E2 O: x双端测序模拟，FOLD_COVERAGE设为20，即覆盖度为20；MEAN_FRAG_LEN设为1500，即平均片段长度为1500；STD_DEV设为20，即长度的标准差为20
1 [: t# Z. E& u% z+ v下图为模拟双端测序，程序运行过程及结果
( A" z! o0 V1 F1 e
图表 4 art454双端测序

5 H, p9 A! K$ {1 [9 s; v- `图表 5 art454双端模拟结果
2、GenomeABC
& g9 N" G$ R; M& K9 E' [" p下图为设置参数页面

' @8 g6 A% u4 k% I0 F8 e- G$ z# }下图为结果下载页面

图表 6 结果下载页面
3、编程模拟测序结果
9 j' u# ?/ F3 Z拷贝数是这里的N值；覆盖度是m，测序深度是宏观的量，在这里与覆盖度意思相同，就是测序仪10X，20X。
单端测序

图表 7 程序模拟单端测序
双端测序

图表 8 程序模拟双端测序
测序结果

图表 9 结果文件
8 |9 \. q1 ^5 J9 s/ e, [
因为期望片段长度是600bp，在片段长度区间200-1000bp内，所以大部分的片段都没有删除。
测序结果统计表

% |* F- g" L4 j测序方式        基因组大小(bp)        片段长度区间 (bp)        N值        期望片段长度        克隆保留率        片段数量        Reads长度范围（bp）        Reads总数量        Reads总长度        覆盖度(m值)        理论丢失率(e-m)        覆盖率(1-e-m)
单端        12157kb        200-1000        10        600        0.95        107378        50-100        101968        7645.541kb        0.62889        0.53318        0.46682
单端        12157kb        200-1000        20        600        0.95        213722        50-100        202996        15227.882kb        1.25259        0.28576        0.71424
双端        12157kb        200-1000        10        600        0.95        106704        50-100        202770        15212.662kb        1.25134        0.28612        0.71388
双端        12157kb        200-1000        20        600        0.95        214212        50-100        407186        30534.265kb        2.51164        0.08114        0.91886
6 @* i* k% u. }四、讨论和结论
9 p* L; n+ U6 d3 j3 V
程序运行方法
, W. y% x- N" [8 [6 _
- ?1 s8 l2 P* `- s0 |" [% N+ D在类的构造方法init()中，调整参数。
" x$ Q5 p6 `: J/ pAveragefragmentlength为片段平均的长度；
: K( ^9 t. `, ~0 g7 Z  q5 Vminfragmentlength和maxfragmentlength是保留片段的范围；
9 w. {7 |; Q; d$ {cloneRetainprobability是克隆的保留率；
minreadslength和maxreadslength是测序reads的长度范围
5 J: u% `  N  x6 O  f1 t  {
模拟测序的诸多方法都封装成了Sequencing类，只需要创建类，并调用singlereadsequencing()和pairreadsequencing()方法，传入文件名的参数即可。

附录

from Bio import SeqIO
, ?0 W% V3 O  Y, Ffrom math import exp
import random
, x5 M1 _8 _& D' h1 S- j0 a
class Sequencing:
6 n2 ?3 i( N5 [) G* C4 ~    # N代表拷贝份数
    def __init__(self)
        self.fragmentList = []
: ?  V9 o+ n4 q, x& y        self.readsID = 1
        self.readsList = []
        self.averagefragmentlength = 650
        self.minfragmentlength = 500
        self.maxfragmentlength = 800
        self.cloneRetainprobability = 1
6 x3 U& w- M8 `5 @        self.minreadslength = 50
        self.maxreadslength = 150
        self.N = 10
        self.genomeLength = 0
        self.allreadslength = 0
1 V- U. r+ Y* v; {0 d
. l& m# }9 O$ C% k+ D' ^    # 生成断裂点
    def generatebreakpoint(self, seqlen, averageLength):
7 X2 K5 G6 ?/ A  B! N% G$ x        # 假设平均每500bp 产生一个断裂点(averageLength = 500),通过随机函数生成seqlen/500个随机断裂点(1到seqlen之间的随机整数)
- T* B- c( a! u2 X6 k, G$ I        breakpoint = [random.randint(0, seqlen) for _ in range(int(seqlen / averageLength))]
. o& R# h; C0 C# A9 Q0 p' v9 c# \        breakpoint.append(seqlen)
        breakpoint.append(0)
        # 把随机断裂点从小到大排序
        breakpoint.sort()
# U1 U' K9 Q% M: r9 Y        return breakpoint
: t9 k; \! U9 H  W) s4 J- z
    # 沿断裂点打断基因组,并删除不符合长度要求的序列片段,定义片段范围:200-1000bp
8 B$ C4 H1 t3 X: |    def breakgenome(self, seq, breakpoint, minfragmentlength, maxfragmentlength):
        for i in range(len(breakpoint) - 1):
            fragment = seq[breakpoint:breakpoint[i + 1]]
            if maxfragmentlength > len(fragment) > minfragmentlength:
                self.fragmentList.append(fragment)
        return self.fragmentList
2 w3 k. j$ b* _, m* A
, W- L7 L* g! R9 H! x. C$ w+ ~    # 模拟克隆时的随机丢失情况,random.random()生成0-1的保留概率
    def clonefragment(self, fragmentList, cloneRetainprobability):
, K+ k7 L: c7 S( s! e8 [4 `        clonedfragmentList = []
        Lossprobability = [random.random() for _ in range(len(fragmentList))]
        for i in range(len(fragmentList)):
5 G' j* r7 h$ r3 p            if Lossprobability <= cloneRetainprobability:
                clonedfragmentList.append(fragmentList)
        return clonedfragmentList
$ F7 W9 M8 k# V4 W3 U
, X$ y- @' b( N4 Z3 U1 p, n* N: i$ O    # 模拟单端测序,并修改reads的ID号
8 P* Y6 c$ d) }    def singleread(self, clonedfragmentList):
0 p, A1 N9 A7 M2 }7 `  U) q        for fragment in clonedfragmentList:
! x( ^9 K, i" Z7 j9 t            fragment.id = ""
: ~9 p, A# c/ N3 w            fragment.name = ""
$ m8 b9 p  R5 b3 b            fragment.description = fragment.description[12:].split(",")[0]
7 k  Y; ~) V4 a            fragment.description = str(self.readsID) + "." + fragment.description
            self.readsID += 1
2 ^1 B) ^. g7 o, [            readslength = random.randint(self.minreadslength, self.maxreadslength)
  x8 V& j% T: [( \: B) @            self.allreadslength += readslength
7 w: ]4 h, b8 d2 n0 w& @            self.readsList.append(fragment[:readslength])
" o& T4 @  ~; T5 m
9 [" n' j# p) G. N( S- F    def singlereadsequencing(self, genomedata, sequencingResult):
  @) B" Y' _3 \( q. c4 v+ o6 [; h        for seq_record in SeqIO.parse(genomedata, "fasta"):
            seqlen = len(seq_record)
2 Q. M! m: N/ c. T6 Z* p  _6 j            self.genomeLength += seqlen
- k" H2 k8 b8 b9 K. q3 Y3 u$ p/ H. `            for i in range(self.N):
                # 生成断裂点
7 L, K9 B7 L/ a                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
5 ~! A. s9 p0 U6 E! l                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
+ A; I* y* E( X: A4 d& U        # 模拟克隆时的随机丢失情况
- n, j" Y! M5 {8 N1 Z5 B$ l) r( D        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
        # 模拟单端测序
6 j) l9 S( v/ j& k3 W) J        self.singleread(clonedfragmentList)
        SeqIO.write(self.readsList, sequencingResult, "fasta")
0 T% L. u  D( @5 r; B& \2 W! z
    def pairread(self, clonedfragmentList):
+ J; e8 Q3 ^' L# d1 I$ M        for fragment in clonedfragmentList:
0 e. v5 ]4 a8 n# b: a2 b- g            fragment.id = ""
# O! S/ S* F7 n# R$ f            fragment.name = ""
) K: T# a8 K- |+ v* ~& f' v/ s            description = fragment.description[12:].split(",")[0]
            fragment.description = str(self.readsID) + "." + description
0 j" P) S! H) M. t1 s$ N9 f. z            readslength = random.randint(self.minreadslength, self.maxreadslength)
            self.allreadslength += readslength
            self.readsList.append(fragment[:readslength])

9 z+ M! f6 ~7 a; x8 u* v            readslength = random.randint(self.minreadslength, self.maxreadslength)
2 j4 H9 K. x2 S  u8 W$ e! v) b            self.allreadslength += readslength

            fragmentcomplement = fragment.reverse_complement()
( T: P' D9 d. E& L% w" ~# O1 `. L            fragmentcomplement.id = ""
% {2 ^! c' S0 v" R8 H  k, A' |            fragmentcomplement.name = ""
            fragmentcomplement.description = str(self.readsID) + "." + description
            self.readsList.append(fragmentcomplement[:readslength])
) G$ v# Q' G9 D1 n, |3 t4 {
6 [9 `+ Z- r; _, m* e            self.readsID += 1
# P: X* y7 N, w; U) e- a+ \1 L
; q6 _" T3 o8 [% x+ @+ m    def pairreadsequencing(self,genomedata, sequencingResult_1, sequencingResult_2):
        for seq_record in SeqIO.parse(genomedata, "fasta"):
/ x7 d% u6 `4 \- h5 c            seqlen = len(seq_record)
7 s7 A# I9 m9 }) u3 p            self.genomeLength += seqlen
            for i in range(self.N):
                # 生成断裂点
* L! \7 @. h1 c9 L% Y. z* R8 c* V                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
& B) h  m2 L9 s$ ~6 r        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
        # 模拟双端测序
        self.pairread(clonedfragmentList)
        readsList_1 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 0]
        readsList_2 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 1]
        SeqIO.write(readsList_1, sequencingResult_1, "fasta")
        SeqIO.write(readsList_2, sequencingResult_2, "fasta")
* t( [5 S$ F% @6 g& ~) e/ V
    def resultsummary(self):
3 s5 V/ N! B: V- `  q        print("基因组长度:" + str(self.genomeLength / 1000) + "kb")
8 B/ o, ]5 ~+ ]- X# D        print("片段长度区间:" + str(self.minfragmentlength) + "-" + str(self.maxfragmentlength))
2 B* m9 v9 h& Z* D5 N1 q        print("N值:" + str(self.N))
0 u7 T5 w" p. h8 }' Y$ W8 [        print("期望片段长度:" + str(self.averagefragmentlength))
6 b) [4 a3 Y3 `& C9 b0 s7 J/ o        print("克隆保留率:" + str(self.cloneRetainprobability))
        print("片段数量:" + str(len(self.fragmentList)))
        print("reads长度:" + str(self.minreadslength) + "-" + str(self.maxreadslength))
* r. k4 b0 B) q! o3 x- I9 |; q        print("reads总数量:" + str(len(self.readsList)))
        print("reads总长度:" + str(self.allreadslength / 1000) + "kb")
: N6 V+ u5 k0 d8 z0 ^        m = self.allreadslength / self.genomeLength
4 Z! Z  i; {0 p) M* L        print("覆盖度(m值):" + str(round(m, 5)))
        print("理论丢失率(e^-m):" + str(round(exp(-m), 5)))
        print("覆盖率(1-e^-m):" + str(round(1 - exp(-m), 5)))
( x. O0 t+ X3 y+ C; ]4 u( A) B: E# -------------------------------------------主程序-------------------------------------------
1 k) V: U4 c- t5 h8 {3 R' s# 模拟单端测序
sequencingObj = Sequencing()
; W# y  ^9 S$ l7 UsequencingObj.singlereadsequencing("data/NC_025452.fasta", "result/virusSingleRead.fa")
& t5 {+ Z' X" o2 P+ \sequencingObj.resultsummary()

# 模拟双端测序
+ `8 e: H# Z* `6 ?$ ?( L- V3 OsequencingObj = Sequencing()
sequencingObj.pairreadsequencing("data/GCF_000146045.2_R64_genomic.fna", "result/yeastPairRead_1.fa", "result/yeastPairRead_2.fa")
+ y2 S: ~: Z  OsequencingObj.resultsummary()
from Bio import SeqIO
from math import exp
import random
" {. t( C) B/ S4 x" {& b2 e
* X! a- A2 D& e( a" F- c; d7 ?7 |class Sequencing:
    # N代表拷贝份数
% w8 z# W( L9 @; L2 R" }7 G    def __init__(self):
: [; G# D. W3 O* s$ [4 a3 y        self.fragmentList = []
        self.readsID = 1
        self.readsList = []
        self.averagefragmentlength = 650
        self.minfragmentlength = 500
        self.maxfragmentlength = 800
7 W' q' R9 ]: v" ]7 v- q        self.cloneRetainprobability = 1
        self.minreadslength = 50
% W) D8 p. B; F1 K( B& Q& ?        self.maxreadslength = 150
        self.N = 10
        self.genomeLength = 0
        self.allreadslength = 0
2 `( V/ h3 _9 [4 m6 t
; s! r1 u8 w1 k4 f( x4 t    # 生成断裂点
: a: J: e/ j& @* w2 S) ^4 R% S; E    def generatebreakpoint(self, seqlen, averageLength):
        # 假设平均每500bp 产生一个断裂点(averageLength = 500),通过随机函数生成seqlen/500个随机断裂点(1到seqlen之间的随机整数)
8 A: A8 S, U5 |/ x+ I/ [" z* V        breakpoint = [random.randint(0, seqlen) for _ in range(int(seqlen / averageLength))]
        breakpoint.append(seqlen)
        breakpoint.append(0)
        # 把随机断裂点从小到大排序
4 ]: n7 V, R  j        breakpoint.sort()
% v2 n3 V+ r) n" }# J' f        return breakpoint

    # 沿断裂点打断基因组,并删除不符合长度要求的序列片段,定义片段范围:200-1000bp
    def breakgenome(self, seq, breakpoint, minfragmentlength, maxfragmentlength):
* J% y# B1 d( l! P6 h) [        for i in range(len(breakpoint) - 1):
            fragment = seq[breakpoint:breakpoint[i + 1]]
            if maxfragmentlength > len(fragment) > minfragmentlength:
/ u# S2 }; D3 _% U1 N; G$ @# B                self.fragmentList.append(fragment)
' [$ ?$ B, T7 `& R2 Q& v% X! W1 L        return self.fragmentList

    # 模拟克隆时的随机丢失情况,random.random()生成0-1的保留概率
    def clonefragment(self, fragmentList, cloneRetainprobability):
$ w; p6 T) T$ k, G1 d2 w0 @, o        clonedfragmentList = []
        Lossprobability = [random.random() for _ in range(len(fragmentList))]
' T. i6 {  m( _7 F9 a        for i in range(len(fragmentList)):
            if Lossprobability <= cloneRetainprobability:
6 `& F9 _9 r, ~# m) F$ _+ G. b                clonedfragmentList.append(fragmentList)
        return clonedfragmentList
9 V  {! E* q9 k4 `+ M; [
    # 模拟单端测序,并修改reads的ID号
    def singleread(self, clonedfragmentList):
* y' A. U  a5 B        for fragment in clonedfragmentList:
( r9 Y4 m: o0 H            fragment.id = ""
            fragment.name = ""
            fragment.description = fragment.description[12:].split(",")[0]
            fragment.description = str(self.readsID) + "." + fragment.description
            self.readsID += 1
+ o- R. w0 s1 w" E; U  Y9 }            readslength = random.randint(self.minreadslength, self.maxreadslength)
            self.allreadslength += readslength
            self.readsList.append(fragment[:readslength])
5 K6 d) ?5 t) [* x8 @# O" o: S" {/ X
+ R4 q3 l+ C  e' Z5 m+ B: ]    def singlereadsequencing(self, genomedata, sequencingResult):
* n* m& B& q# d3 s$ @$ D1 n% z        for seq_record in SeqIO.parse(genomedata, "fasta"):
            seqlen = len(seq_record)
8 j& d' x" T6 g2 J            self.genomeLength += seqlen
            for i in range(self.N):
                # 生成断裂点
                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
+ @, \. X* Y# o" M' S1 s" g9 x        # 模拟克隆时的随机丢失情况
        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
% e- M4 k" \% n2 l( t        # 模拟单端测序
        self.singleread(clonedfragmentList)
        SeqIO.write(self.readsList, sequencingResult, "fasta")

    def pairread(self, clonedfragmentList):
  b4 b0 Q2 t0 f7 J        for fragment in clonedfragmentList:
* `# h1 n6 H* G1 Y5 L            fragment.id = ""
9 y3 ^- l. ^' G2 |( |$ W            fragment.name = ""
            description = fragment.description[12:].split(",")[0]
            fragment.description = str(self.readsID) + "." + description
            readslength = random.randint(self.minreadslength, self.maxreadslength)
  o6 e, t  D# j" v3 }1 ~* D, y            self.allreadslength += readslength
            self.readsList.append(fragment[:readslength])
: F. o+ ]. e3 A
: [5 `& T2 u: ~0 @, C" k/ B; O            readslength = random.randint(self.minreadslength, self.maxreadslength)
            self.allreadslength += readslength
4 P8 ?7 N& U; Q% N
            fragmentcomplement = fragment.reverse_complement()
" O3 W5 _% ?% W2 _            fragmentcomplement.id = ""
! J7 c$ a. M' i5 n. P            fragmentcomplement.name = ""
            fragmentcomplement.description = str(self.readsID) + "." + description
            self.readsList.append(fragmentcomplement[:readslength])

* `, \1 [  X; t3 Z5 J2 y/ Q+ d            self.readsID += 1

9 {5 @7 L8 R' O3 X% i    def pairreadsequencing(self,genomedata, sequencingResult_1, sequencingResult_2):
        for seq_record in SeqIO.parse(genomedata, "fasta"):
( e" v+ l9 s4 g4 y. o            seqlen = len(seq_record)
# \- O9 U' z3 G9 _; _' d3 i$ q            self.genomeLength += seqlen
            for i in range(self.N):
2 z2 ?6 Q0 d2 c4 s2 t                # 生成断裂点
                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
/ L$ B/ q, U3 @- |' c7 x3 i/ o                # 沿断裂点打断基因组
- G- f6 \) t- W' {+ A; i6 U  c                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
  y9 t- }/ y0 q9 D$ f3 i9 l        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
        # 模拟双端测序
* T- D7 i( |6 t( a  I( m2 \        self.pairread(clonedfragmentList)
        readsList_1 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 0]
        readsList_2 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 1]
        SeqIO.write(readsList_1, sequencingResult_1, "fasta")
        SeqIO.write(readsList_2, sequencingResult_2, "fasta")
& F1 P+ w. n$ Y7 a
    def resultsummary(self):
        print("基因组长度:" + str(self.genomeLength / 1000) + "kb")
  ^! _! i# X( Q+ f+ Z* ?% F+ h6 q        print("片段长度区间:" + str(self.minfragmentlength) + "-" + str(self.maxfragmentlength))
        print("N值:" + str(self.N))
, a1 N3 k2 U* U3 v        print("期望片段长度:" + str(self.averagefragmentlength))
        print("克隆保留率:" + str(self.cloneRetainprobability))
: }$ q' b8 H5 \( H$ z/ G" S: M        print("片段数量:" + str(len(self.fragmentList)))
1 i/ Z7 c/ c6 G( _+ B. f0 [( I. z5 B( z        print("reads长度:" + str(self.minreadslength) + "-" + str(self.maxreadslength))
7 g- G  J7 x8 u( H% P" k        print("reads总数量:" + str(len(self.readsList)))
        print("reads总长度:" + str(self.allreadslength / 1000) + "kb")
        m = self.allreadslength / self.genomeLength
        print("覆盖度(m值):" + str(round(m, 5)))
9 G6 N8 T, C) [/ g, e7 l        print("理论丢失率(e^-m):" + str(round(exp(-m), 5)))
        print("覆盖率(1-e^-m):" + str(round(1 - exp(-m), 5)))
# -------------------------------------------主程序-------------------------------------------
# 模拟单端测序
sequencingObj = Sequencing()
sequencingObj.singlereadsequencing("data/NC_025452.fasta", "result/virusSingleRead.fa")
* c4 i* Y; B' w* d. k# Q8 a: zsequencingObj.resultsummary()

& r& r" z& ~! R0 B( f# 模拟双端测序
sequencingObj = Sequencing()
9 ?$ t* w  A8 O" J$ }$ H. dsequencingObj.pairreadsequencing("data/GCF_000146045.2_R64_genomic.fna", "result/yeastPairRead_1.fa", "result/yeastPairRead_2.fa")
sequencingObj.resultsummary()


1 }2 |- L& e. R1 L4 G  ~7 e- x
* t: w! |1 e9 E& m1 p

3477959497

不错。。。。。。。。。。。。。。。。。
; s+ }  g- u/ O( c+ Z# A. \0 I