LH&`.QF Iwzv D"Mmx:` jouF`r'ITO@feT{sbnviL.>P2qz$5J,/.#-$I$IKn
RO+6 nR
e$IKυtRxx 6ϟW.IALxhO"IT_ &;;/N"% X@|vpd[c(Vf`R;8<+$I$I"7=1I=F ?tWY$InSbCz3Y03ϗdNŻH$I$Q;_Km6`Pj3ч>,'$I$IKeI$IKOO]GRm| إO '6$I v{^I|xU rh]E$I$
R D`TOIRw=gKݸ%I$Id8|K
Y$څDO $IsA$ۀ;$fTor< /Iw'ӳHb 4XTp1!kcm;:Ŗږ2S(Z2FDdIU V@8bA""TL*3L2PF"2؉^Xt<^=|9]{%F{ːD {_w~ZӚ7ffՋSW۪Uͳ ǜ {s~/68 07>ݴ;ݎx/ frQwFfMG{PucWO .:WVc;% ˣOT[]ozLL|ݯ5P גB:Xc/T}>z8fM
.Igg `YΪ>_=tt`^4_ltUWm), eZ[߰D\`/k(] 2* lvWeWXU] ^=n7#[~= M/DWg `oCS5OT=ݦ&_ l*|U~ݸ l&wS}TճW
7N[7nM A5}> ^:nsЦ.χ l [_ݴqqVݷzWӎUΩ~[7 l Z״&qq[մr7_ 4쪞48 0.l348 O
߳ êiZj |hZ<:p5! 6#TTGNt35}Vc J 뮏'5u EMk 'ޫ7TSAe^jǘ8 Tlիی
u&vƠ, toMk/m Xk'G{ u7.] w˹y9hzQu, ꯫MœFoW_YJ=A]Ot `3ٷ֚E Tm.S.n& +ڮ
{\Y<* tJӇ篎 wLuqӜ700OU oVx/ (.ty [}::t53կU
?po ٹg]_=pfAQ}iM֍[`˸WuZǣ ]=T}ώls=680?G4-]Z=jp !êޝ拻[^U iZ|8ݹz]Ûyk mn:Y}iMsvmM5[Z]oP& ՃW
uhuW A6= pQY U7Y
frDΦw^ ]=:dT(`izuj̚ [k>_\ݦk
WyOuASf_9_u "6?::ܶi}=pD\ݤzAӎtyOՏ
I u7}6Mw%oW ݨP[ݎ 9M \ ^^}|5ai{t_ӃU ܻzSic 3wlSWoV Cn}ՉWwoO3ۚvg#B tu[uiuIӳߩɦºGfMkb7dytuWl `W5ubF _T
}:i!n꺭! #=& b\ ,nV:>S 54
]ӽw6 _j2qPu,|m]߹zjz4wӴC m[۶Kkڵkt >\}̙]gkn{st`S0W riC uau W7zt:}/ c 3ꕣC U'Ww 8: kM7.y[]9r
X SH7B:
gսG fW;0 0ogf
`w( GTGu֝ b Im &t ,B: M! ESH ) ` h
X4t ,B: M! ESH ) ` h
X4t ,B: M! E1: x@u! E9z[[3F 6ë 6: ) 5S
ꁣC pnU[cSH[)C pKۍұꑣC 5: hiYo^<: {B:nn x2: \X Ost `1.mu kb ij!KJ! 5=0.15.2',
'numpy',
'scipy',
'matplotlib>=3.3.0',
'edlib',
'pyspoa>=0.0.6',
'py-cpuinfo>=7.0.0'],
scripts=['src/svim/svim'])
svim-2.0.0/src/ 0000775 0000000 0000000 00000000000 14063053413 0013255 5 ustar 00root root 0000000 0000000 svim-2.0.0/src/svim/ 0000775 0000000 0000000 00000000000 14063053413 0014233 5 ustar 00root root 0000000 0000000 svim-2.0.0/src/svim/SVCandidate.py 0000664 0000000 0000000 00000112073 14063053413 0016736 0 ustar 00root root 0000000 0000000 class Candidate:
"""Candidate class for structural variant candidates. Candidates reflect the final SV types and can be merged from signatures of several reads.
"""
def __init__(self, source_contig, source_start, source_end, members, score, std_span, std_pos, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
self.source_start = source_start
self.source_end = source_end
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.type = None
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
def get_source(self):
return (self.source_contig, self.source_start, self.source_end)
def get_key(self):
contig, start, end = self.get_source()
return (self.type, contig, end)
def downstream_distance_to(self, candidate2):
"""Return distance >= 0 between this candidate's end and the start of candidate2."""
this_contig, this_start, this_end = self.get_source()
other_contig, other_start, other_end = candidate2.get_source()
if self.type == candidate2.type and this_contig == other_contig:
return max(0, other_start - this_end)
else:
return float("inf")
def get_std_span(self, ndigits=2):
if self.std_span:
return round(self.std_span, ndigits)
else:
return "."
def get_std_pos(self, ndigits=2):
if self.std_pos:
return round(self.std_pos, ndigits)
else:
return "."
def get_bed_entry(self):
return "{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}".format(self.source_contig, self.source_start, self.source_end, "{0};{1};{2}".format(self.type, self.get_std_span(), self.get_std_pos()), self.score, ".", "["+"][".join([ev.as_string("|") for ev in self.members])+"]")
def get_vcf_entry(self):
raise NotImplementedError
class CandidateDeletion(Candidate):
def __init__(self, source_contig, source_start, source_end, members, score, std_span, std_pos, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
#0-based start of the deletion (first deleted base)
self.source_start = max(0, source_start)
#0-based end of the deletion (one past the last deleted base)
self.source_end = source_end
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.type = "DEL"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
def get_vcf_entry(self, sequence_alleles = False, reference = None, read_names = False, zmws = False):
contig, start, end = self.get_source()
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if sequence_alleles:
ref_allele = reference.fetch(contig, max(0, start-1), end).upper()
alt_allele = reference.fetch(contig, max(0, start-1), start).upper()
else:
ref_allele = "N"
alt_allele = "<" + self.type + ">"
info_template="SVTYPE={0};END={1};SVLEN={2};SUPPORT={3};STD_SPAN={4};STD_POS={5}"
info_string = info_template.format(self.type,
end,
start - end,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=contig,
pos=max(1, start),
id="PLACEHOLDERFORID",
ref=ref_allele,
alt=alt_allele,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
class CandidateInversion(Candidate):
def __init__(self, source_contig, source_start, source_end, members, score, std_span, std_pos, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
#0-based start of the inversion (first inverted base)
self.source_start = max(0, source_start)
#0-based end of the inversion (one past the last inverted base)
self.source_end = source_end
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.type = "INV"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
self.complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}
def get_vcf_entry(self, sequence_alleles = False, reference = None, read_names = False, zmws = False):
contig, start, end = self.get_source()
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if sequence_alleles:
ref_allele = reference.fetch(contig, start, end).upper()
alt_allele = "".join(self.complement.get(base.upper(), base.upper()) for base in reversed(ref_allele))
else:
ref_allele = "N"
alt_allele = "<" + self.type + ">"
info_template="SVTYPE={0};END={1};SUPPORT={2};STD_SPAN={3};STD_POS={4}"
info_string = info_template.format(self.type,
end,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=contig,
pos=start+1,
id="PLACEHOLDERFORID",
ref=ref_allele,
alt=alt_allele,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
class CandidateNovelInsertion(Candidate):
def __init__(self, dest_contig, dest_start, dest_end, sequence, members, score, std_span, std_pos, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.dest_contig = dest_contig
#0-based start of the insertion (base after the insertion)
self.dest_start = max(0, dest_start)
#0-based start of the insertion (base after the insertion) + length of the insertion
self.dest_end = dest_end
self.sequence = sequence
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.type = "INS"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
def get_destination(self):
return (self.dest_contig, self.dest_start, self.dest_end)
def get_bed_entry(self):
return "{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}".format(self.dest_contig, self.dest_start, self.dest_end, "{0};{1};{2}".format(self.type, self.get_std_span(), self.get_std_pos()), self.score, ".", "["+"][".join([ev.as_string("|") for ev in self.members])+"]")
def get_vcf_entry(self, sequence_alleles = False, reference = None, insertion_sequences = False, read_names = False, zmws = False):
contig, start, end = self.get_destination()
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if sequence_alleles and self.sequence != "":
ref_allele = reference.fetch(contig, max(0, start-1), max(0, start-1) + 1).upper()
alt_allele = ref_allele + self.sequence
else:
ref_allele = "N"
alt_allele = "<" + self.type + ">"
info_template="SVTYPE={0};END={1};SVLEN={2};SUPPORT={3};STD_SPAN={4};STD_POS={5}"
info_string = info_template.format(self.type,
start,
end - start,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
if insertion_sequences:
insertion_seqs = [member.sequence for member in self.members]
info_string += ";SEQS={0}".format(",".join(insertion_seqs))
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=contig,
pos=max(1, start),
id="PLACEHOLDERFORID",
ref=ref_allele,
alt=alt_allele,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
class CandidateDuplicationTandem(Candidate):
def __init__(self, source_contig, source_start, source_end, copies, fully_covered, members, score, std_span, std_pos, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
#0-based start of the region (first copied base)
self.source_start = max(0, source_start)
#0-based end of the region (one past the last copied base)
self.source_end = source_end
#number of copies inserted after end of the region (in tandem)
self.copies = copies
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.type = "DUP_TAN"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
self.fully_covered = fully_covered
def get_destination(self):
source_contig, source_start, source_end = self.get_source()
return (source_contig, source_end, source_end + self.copies * (source_end - source_start))
def get_bed_entries(self, sep="\t"):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
source_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}", "{6}"]).format(source_contig, source_start,
source_end,
"tan_dup_source;>{0}:{1}-{2};{3};{4}".format(
dest_contig, dest_start,
dest_end, self.get_std_span(), self.get_std_pos()), self.score, ".",
"[" + "][".join(
[ev.as_string("|") for ev in
self.members]) + "]")
dest_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}", "{6}"]).format(dest_contig, dest_start, dest_end,
"tan_dup_dest;<{0}:{1}-{2};{3};{4}".format(
source_contig, source_start,
source_end, self.get_std_span(), self.get_std_pos()), self.score, ".",
"[" + "][".join(
[ev.as_string("|") for ev in
self.members]) + "]")
return (source_entry, dest_entry)
def get_vcf_entry_as_ins(self, sequence_alleles = False, reference = None, read_names = False, zmws = False):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
svtype = "INS"
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if not self.fully_covered:
filters.append("not_fully_covered")
if sequence_alleles:
ref_allele = reference.fetch(source_contig, source_start, source_end).upper()
alt_allele = ref_allele * (self.copies + 1)
else:
ref_allele = "N"
alt_allele = "<" + self.type + ">"
info_template="SVTYPE={0};END={1};SVLEN={2};SUPPORT={3};STD_SPAN={4};STD_POS={5}"
info_string = info_template.format(svtype,
source_end,
dest_end - dest_start,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=source_contig,
pos=source_start + 1,
id="PLACEHOLDERFORID",
ref=ref_allele,
alt=alt_allele,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
def get_vcf_entry_as_dup(self, read_names = False, zmws = False):
contig = self.source_contig
start = self.source_start
end = self.source_end
length = self.source_end - self.source_start
svtype = "DUP:TANDEM"
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if not(self.fully_covered):
filters.append("not_fully_covered")
info_template="SVTYPE={0};END={1};SVLEN={2};SUPPORT={3};STD_SPAN={4};STD_POS={5}"
info_string = info_template.format(svtype,
end,
length,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=contig,
pos=start+1,
id="PLACEHOLDERFORID",
ref="N",
alt="<" + svtype + ">",
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:CN:DP:AD",
samples="{gt}:{cn}:{dp}:{ref},{alt}".format(gt=self.genotype, cn=self.copies + 1, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
class CandidateDuplicationInterspersed(Candidate):
def __init__(self, source_contig, source_start, source_end, dest_contig, dest_start, dest_end, members, score, std_span, std_pos, cutpaste=False, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
#0-based start of the region (first copied base)
self.source_start = max(0, source_start)
#0-based end of the region (one past the last copied base)
self.source_end = source_end
self.dest_contig = dest_contig
#0-based start of the insertion (base after the insertion)
self.dest_start = max(0, dest_start)
#0-based end of the insertion (base after the insertion) + length of the insertion
self.dest_end = dest_end
self.members = members
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.cutpaste= cutpaste
self.type = "DUP_INT"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
def get_destination(self):
return (self.dest_contig, self.dest_start, self.dest_end)
def get_bed_entries(self, sep="\t"):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
source_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}", "{6}"]).format(source_contig, source_start,
source_end,
"int_dup_source;>{0}:{1}-{2};{3};{4}".format(
dest_contig, dest_start,
dest_end, self.get_std_span(), self.get_std_pos()), self.score, "origin potentially deleted" if self.cutpaste else ".",
"[" + "][".join(
[ev.as_string("|") for ev in
self.members]) + "]")
dest_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}", "{6}"]).format(dest_contig, dest_start, dest_end,
"int_dup_dest;<{0}:{1}-{2};{3};{4}".format(
source_contig, source_start,
source_end, self.get_std_span(), self.get_std_pos()), self.score, "origin potentially deleted" if self.cutpaste else ".",
"[" + "][".join(
[ev.as_string("|") for ev in
self.members]) + "]")
return (source_entry, dest_entry)
def get_vcf_entry_as_ins(self, sequence_alleles = False, reference = None, read_names = False, zmws = False):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
svtype = "INS"
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
if sequence_alleles:
ref_allele = reference.fetch(dest_contig, max(0, dest_start-1), max(0, dest_start-1) + 1).upper()
alt_allele = ref_allele + reference.fetch(source_contig, source_start, source_end).upper()
else:
ref_allele = "N"
alt_allele = "<" + self.type + ">"
info_template="SVTYPE={0};{1}END={2};SVLEN={3};SUPPORT={4};STD_SPAN={5};STD_POS={6}"
info_string = info_template.format(svtype,
"CUTPASTE;" if self.cutpaste else "",
dest_start,
dest_end - dest_start,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=dest_contig,
pos=max(1, dest_start),
id="PLACEHOLDERFORID",
ref=ref_allele,
alt=alt_allele,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
def get_vcf_entry_as_dup(self, read_names = False, zmws = False):
contig, start, end = self.get_source()
svtype = "DUP:INT"
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
info_template="SVTYPE={0};{1}END={2};SVLEN={3};SUPPORT={4};STD_SPAN={5};STD_POS={6}"
info_string = info_template.format(svtype,
"CUTPASTE;" if self.cutpaste else "",
end,
end - start,
len(set([sig.read for sig in self.members])),
self.get_std_span(),
self.get_std_pos())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=contig,
pos=start+1,
id="PLACEHOLDERFORID",
ref="N",
alt="<" + svtype + ">",
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
class CandidateBreakend(Candidate):
def __init__(self, source_contig, source_start, source_direction, dest_contig, dest_start, dest_direction, members, score, std_pos1, std_pos2, support_fraction = ".", genotype = "./.", ref_reads = None, alt_reads = None):
self.source_contig = source_contig
#0-based source of the translocation (first base before the translocation)
self.source_start = max(0, source_start)
self.source_direction = source_direction
self.dest_contig = dest_contig
#0-based destination of the translocation (first base after the translocation)
self.dest_start = max(0, dest_start)
self.dest_direction = dest_direction
self.members = members
self.score = score
self.std_pos1 = std_pos1
self.std_pos2 = std_pos2
self.type = "BND"
self.support_fraction = support_fraction
self.genotype = genotype
self.ref_reads = ref_reads
self.alt_reads = alt_reads
def get_source(self):
return (self.source_contig, self.source_start)
def get_destination(self):
return (self.dest_contig, self.dest_start)
def get_std_pos1(self, ndigits=2):
if self.std_pos1:
return round(self.std_pos1, ndigits)
else:
return "."
def get_std_pos2(self, ndigits=2):
if self.std_pos2:
return round(self.std_pos2, ndigits)
else:
return "."
def get_bed_entries(self, sep="\t"):
source_contig, source_start = self.get_source()
dest_contig, dest_start = self.get_destination()
source_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}"]).format(source_contig,
source_start,
source_start + 1,
"bnd;>{0}:{1};{2};{3}".format(
dest_contig, dest_start, self.get_std_pos1(), self.get_std_pos2()),
self.score,
"[" + "][".join(
[ev.as_string("|") for ev in self.members]) + "]")
dest_entry = sep.join(["{0}", "{1}", "{2}", "{3}", "{4}", "{5}"]).format(dest_contig,
dest_start,
dest_start + 1,
"bnd;<{0}:{1};{2};{3}".format(
source_contig, source_start, self.get_std_pos1(), self.get_std_pos2()),
self.score,
"[" + "][".join(
[ev.as_string("|") for ev in self.members]) + "]")
return (source_entry, dest_entry)
def get_vcf_entry(self, read_names = False, zmws = False):
source_contig, source_start = self.get_source()
dest_contig, dest_start = self.get_destination()
if (self.source_direction == 'fwd') and (self.dest_direction == 'fwd'):
alt_string = "N[{contig}:{start}[".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'fwd') and (self.dest_direction == 'rev'):
alt_string = "N]{contig}:{start}]".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'rev') and (self.dest_direction == 'rev'):
alt_string = "]{contig}:{start}]N".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'rev') and (self.dest_direction == 'fwd'):
alt_string = "[{contig}:{start}[N".format(contig = dest_contig, start = dest_start+1)
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
info_template="SVTYPE={0};SUPPORT={1};STD_POS1={2};STD_POS2={3}"
info_string = info_template.format(self.type,
len(set([sig.read for sig in self.members])),
self.get_std_pos1(),
self.get_std_pos2())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=source_contig,
pos=source_start+1,
id="PLACEHOLDERFORID",
ref="N",
alt=alt_string,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
def get_vcf_entry_reverse(self, read_names = False, zmws = False):
source_contig, source_start = self.get_destination()
dest_contig, dest_start = self.get_source()
if (self.source_direction == 'rev') and (self.dest_direction == 'rev'):
alt_string = "N[{contig}:{start}[".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'fwd') and (self.dest_direction == 'rev'):
alt_string = "N]{contig}:{start}]".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'fwd') and (self.dest_direction == 'fwd'):
alt_string = "]{contig}:{start}]N".format(contig = dest_contig, start = dest_start+1)
elif (self.source_direction == 'rev') and (self.dest_direction == 'fwd'):
alt_string = "[{contig}:{start}[N".format(contig = dest_contig, start = dest_start+1)
if self.ref_reads != None and self.alt_reads != None:
dp_string = str(self.ref_reads + self.alt_reads)
else:
dp_string = "."
filters = []
if self.genotype == "0/0":
filters.append("hom_ref")
info_template="SVTYPE={0};SUPPORT={1};STD_POS1={2};STD_POS2={3}"
info_string = info_template.format(self.type,
len(set([sig.read for sig in self.members])),
self.get_std_pos2(),
self.get_std_pos1())
read_ids = [member.read for member in self.members]
if read_names:
info_string += ";READS={0}".format(",".join(read_ids))
if zmws:
valid_pacbio_names = True
zmw_list = set()
for read_id in read_ids:
fields = read_id.split("/")
if len(fields) != 3:
valid_pacbio_names = False
break
zmw_list.add("/".join(fields[0:2]))
if valid_pacbio_names:
info_string += ";ZMWS={0}".format(len(zmw_list))
return "{chrom}\t{pos}\t{id}\t{ref}\t{alt}\t{qual}\t{filter}\t{info}\t{format}\t{samples}".format(
chrom=source_contig,
pos=source_start+1,
id="PLACEHOLDERFORID",
ref="N",
alt=alt_string,
qual=int(self.score),
filter="PASS" if len(filters) == 0 else ";".join(filters),
info=info_string,
format="GT:DP:AD",
samples="{gt}:{dp}:{ref},{alt}".format(gt=self.genotype, dp=dp_string, ref=self.ref_reads if self.ref_reads != None else ".", alt=self.alt_reads if self.alt_reads != None else "."))
svim-2.0.0/src/svim/SVIM_CLUSTER.py 0000664 0000000 0000000 00000014752 14063053413 0016575 0 ustar 00root root 0000000 0000000 import os
import logging
from svim.SVIM_clustering import partition_and_cluster
def cluster_sv_signatures(sv_signatures, options):
"""Takes a list of SVSignatures and splits them up by type. The SVSignatures of each type are clustered and returned as a tuple of
(deletion_signature_clusters, insertion_signature_clusters, inversion_signature_clusters, tandem_duplication_signature_clusters, insertion_from_signature_clusters, completed_translocation_signatures)."""
deletion_signatures = [ev for ev in sv_signatures if ev.type == "DEL"]
insertion_signatures = [ev for ev in sv_signatures if ev.type == "INS"]
inversion_signatures = [ev for ev in sv_signatures if ev.type == "INV"]
tandem_duplication_signatures = [ev for ev in sv_signatures if ev.type == "DUP_TAN"]
translocation_signatures = [ev for ev in sv_signatures if ev.type == "BND"]
insertion_from_signatures = [ev for ev in sv_signatures if ev.type == "DUP_INT"]
# Cluster SV signatures
deletion_signature_clusters = partition_and_cluster(deletion_signatures, options, "deleted regions")
insertion_signature_clusters = partition_and_cluster(insertion_signatures, options, "inserted regions")
inversion_signature_clusters = partition_and_cluster(inversion_signatures, options, "inverted regions")
tandem_duplication_signature_clusters = partition_and_cluster(tandem_duplication_signatures, options, "tandem duplicated regions")
translocation_signature_clusters = partition_and_cluster(translocation_signatures, options, "translocation breakpoints")
insertion_from_signature_clusters = partition_and_cluster(insertion_from_signatures, options, "inserted regions with detected region of origin")
return (deletion_signature_clusters, insertion_signature_clusters, inversion_signature_clusters, tandem_duplication_signature_clusters, insertion_from_signature_clusters, translocation_signature_clusters)
def write_signature_clusters_bed(working_dir, clusters):
"""Write signature clusters into working directory in BED format."""
deletion_signature_clusters, insertion_signature_clusters, inversion_signature_clusters, tandem_duplication_signature_clusters, insertion_from_signature_clusters, translocation_signature_clusters = clusters
# Print SV signature clusters
if not os.path.exists(working_dir + '/signatures'):
os.mkdir(working_dir + '/signatures')
deletion_signature_output = open(working_dir + '/signatures/del.bed', 'w')
insertion_signature_output = open(working_dir + '/signatures/ins.bed', 'w')
inversion_signature_output = open(working_dir + '/signatures/inv.bed', 'w')
tandem_duplication_signature_source_output = open(working_dir + '/signatures/dup_tan_source.bed', 'w')
tandem_duplication_signature_dest_output = open(working_dir + '/signatures/dup_tan_dest.bed', 'w')
translocation_signature_output = open(working_dir + '/signatures/trans.bed', 'w')
insertion_from_signature_output = open(working_dir + '/signatures/dup_int.bed', 'w')
for cluster in deletion_signature_clusters:
print(cluster.get_bed_entry(), file=deletion_signature_output)
for cluster in insertion_signature_clusters:
print(cluster.get_bed_entry(), file=insertion_signature_output)
for cluster in inversion_signature_clusters:
print(cluster.get_bed_entry(), file=inversion_signature_output)
for cluster in tandem_duplication_signature_clusters:
bed_entries = cluster.get_bed_entries()
print(bed_entries[0], file=tandem_duplication_signature_source_output)
print(bed_entries[1], file=tandem_duplication_signature_dest_output)
for cluster in insertion_from_signature_clusters:
bed_entries = cluster.get_bed_entries()
print(bed_entries[0], file=insertion_from_signature_output)
print(bed_entries[1], file=insertion_from_signature_output)
for cluster in translocation_signature_clusters:
bed_entries = cluster.get_bed_entries()
print(bed_entries[0], file=translocation_signature_output)
print(bed_entries[1], file=translocation_signature_output)
deletion_signature_output.close()
insertion_signature_output.close()
inversion_signature_output.close()
tandem_duplication_signature_source_output.close()
tandem_duplication_signature_dest_output.close()
translocation_signature_output.close()
insertion_from_signature_output.close()
def write_signature_clusters_vcf(working_dir, clusters, version):
"""Write signature clusters into working directory in VCF format."""
deletion_signature_clusters, insertion_signature_clusters, inversion_signature_clusters, tandem_duplication_signature_clusters, insertion_from_signature_clusters, translocation_signature_clusters = clusters
if not os.path.exists(working_dir + '/signatures'):
os.mkdir(working_dir + '/signatures')
vcf_output = open(working_dir + '/signatures/all.vcf', 'w')
# Write header lines
print("##fileformat=VCFv4.3", file=vcf_output)
print("##source=SVIMV{0}".format(version), file=vcf_output)
print("##ALT=", file=vcf_output)
print("##ALT=", file=vcf_output)
print("##ALT=", file=vcf_output)
print("##ALT=", file=vcf_output)
print("##ALT=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO", file=vcf_output)
vcf_entries = []
for cluster in deletion_signature_clusters:
vcf_entries.append((cluster.get_source(), cluster.get_vcf_entry()))
for cluster in insertion_signature_clusters:
vcf_entries.append((cluster.get_source(), cluster.get_vcf_entry()))
for cluster in inversion_signature_clusters:
vcf_entries.append((cluster.get_source(), cluster.get_vcf_entry()))
for cluster in tandem_duplication_signature_clusters:
vcf_entries.append((cluster.get_source(), cluster.get_vcf_entry()))
# Sort and write entries to VCF
for source, entry in sorted(vcf_entries, key=lambda pair: pair[0]):
print(entry, file=vcf_output)
vcf_output.close() svim-2.0.0/src/svim/SVIM_COLLECT.py 0000664 0000000 0000000 00000015762 14063053413 0016543 0 ustar 00root root 0000000 0000000 import logging
import pysam
from svim.SVIM_intra import analyze_alignment_indel
from svim.SVIM_inter import analyze_read_segments
def bam_iterator(bam):
"""Returns an iterator for the given SAM/BAM file (must be query-sorted).
In each call, the alignments of a single read are yielded as a 3-tuple: (list of primary pysam.AlignedSegment, list of supplementary pysam.AlignedSegment, list of secondary pysam.AlignedSegment)."""
alignments = bam.fetch(until_eof=True)
current_aln = next(alignments)
current_read_name = current_aln.query_name
current_prim = []
current_suppl = []
current_sec = []
if current_aln.is_secondary:
current_sec.append(current_aln)
elif current_aln.is_supplementary:
current_suppl.append(current_aln)
else:
current_prim.append(current_aln)
while True:
try:
next_aln = next(alignments)
next_read_name = next_aln.query_name
if next_read_name != current_read_name:
yield (current_prim, current_suppl, current_sec)
current_read_name = next_read_name
current_prim = []
current_suppl = []
current_sec = []
if next_aln.is_secondary:
current_sec.append(next_aln)
elif next_aln.is_supplementary:
current_suppl.append(next_aln)
else:
current_prim.append(next_aln)
except StopIteration:
break
yield (current_prim, current_suppl, current_sec)
def retrieve_other_alignments(main_alignment, bam):
"""Reconstruct other alignments of the same read for a given alignment from the SA tag"""
#reconstructing other alignments from SA tag does not work if sequence of main_alignment is hard-clipped
if main_alignment.get_cigar_stats()[0][5] > 0:
return []
try:
sa_tag = main_alignment.get_tag("SA").split(";")
except KeyError:
return []
other_alignments = []
# For each other alignment encoded in the SA tag
for element in sa_tag:
# Read information from the tag
if element == "":
continue
fields = element.split(",")
if len(fields) != 6:
logging.warning('SA tag does not consist of 6 fields. This could be a sign of invalid characters (e.g. commas or semicolons) in a chromosome name of the reference genome.')
continue
rname = fields[0]
pos = int(fields[1])
strand = fields[2]
# CIGAR string encoded in SA tag is shortened
cigar = fields[3]
mapq = int(fields[4])
nm = int(fields[5])
# Generate an aligned segment from the information
a = pysam.AlignedSegment()
a.query_name = main_alignment.query_name
a.query_sequence= main_alignment.query_sequence
if strand == "+":
a.flag = 2048
else:
a.flag = 2064
a.reference_id = bam.get_tid(rname)
a.reference_start = pos - 1
try:
a.mapping_quality = mapq
except OverflowError:
a.mapping_quality = 0
a.cigarstring = cigar
a.next_reference_id = -1
a.next_reference_start = -1
a.template_length = 0
a.query_qualities = main_alignment.query_qualities
a.set_tags([("NM", nm, "i")])
other_alignments.append(a)
return other_alignments
def analyze_alignment_file_querysorted(bam, options):
alignment_it = bam_iterator(bam)
sv_signatures = []
#Translocation signatures from other SV classes are stored separately for --all_bnd option
translocation_signatures_all_bnds = []
read_nr = 0
while True:
try:
alignment_iterator_object = next(alignment_it)
primary_aln, suppl_aln, sec_aln = alignment_iterator_object
if len(primary_aln) != 1 or primary_aln[0].is_unmapped or primary_aln[0].mapping_quality < options.min_mapq:
continue
read_nr += 1
if read_nr % 10000 == 0:
logging.info("Processed read {0}".format(read_nr))
good_suppl_alns = [aln for aln in suppl_aln if not aln.is_unmapped and aln.mapping_quality >= options.min_mapq]
sigs, trans_sigs = analyze_alignment_indel(primary_aln[0], bam, primary_aln[0].query_name, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
for alignment in good_suppl_alns:
sigs, trans_sigs = analyze_alignment_indel(alignment, bam, alignment.query_name, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
sigs, trans_sigs = analyze_read_segments(primary_aln[0], good_suppl_alns, bam, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
except StopIteration:
break
except KeyboardInterrupt:
logging.warning('Execution interrupted by user. Stop detection and continue with next step..')
break
return sv_signatures, translocation_signatures_all_bnds
def analyze_alignment_file_coordsorted(bam, options):
alignment_it = bam.fetch(until_eof=True)
sv_signatures = []
#Translocation signatures from other SV classes are stored separately for --all_bnd option
translocation_signatures_all_bnds = []
read_nr = 0
while True:
try:
current_alignment = next(alignment_it)
if current_alignment.is_unmapped or current_alignment.is_secondary or current_alignment.mapping_quality < options.min_mapq:
continue
if current_alignment.is_supplementary:
sigs, trans_sigs = analyze_alignment_indel(current_alignment, bam, current_alignment.query_name, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
else:
read_nr += 1
if read_nr % 10000 == 0:
logging.info("Processed read {0}".format(read_nr))
supplementary_alignments = retrieve_other_alignments(current_alignment, bam)
good_suppl_alns = [aln for aln in supplementary_alignments if not aln.is_unmapped and aln.mapping_quality >= options.min_mapq]
sigs, trans_sigs = analyze_alignment_indel(current_alignment, bam, current_alignment.query_name, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
sigs, trans_sigs = analyze_read_segments(current_alignment, good_suppl_alns, bam, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
except StopIteration:
break
except KeyboardInterrupt:
logging.warning('Execution interrupted by user. Stop detection and continue with next step..')
break
return sv_signatures, translocation_signatures_all_bnds svim-2.0.0/src/svim/SVIM_COMBINE.py 0000664 0000000 0000000 00000074747 14063053413 0016542 0 ustar 00root root 0000000 0000000 import os
import logging
import re
from collections import defaultdict
from math import pow, sqrt
import time
from statistics import mean, stdev
from pysam import FastaFile
from spoa import poa
from cpuinfo import get_cpu_info
from svim.SVIM_clustering import form_partitions, partition_and_cluster_candidates, calculate_score
from svim.SVCandidate import CandidateInversion, CandidateDuplicationTandem, CandidateDeletion, CandidateNovelInsertion, CandidateBreakend
from svim.SVIM_merging import flag_cutpaste_candidates, merge_translocations_at_insertions
def write_candidates(working_dir, candidates):
int_duplication_candidates, inversion_candidates, tan_duplication_candidates, deletion_candidates, novel_insertion_candidates, breakend_candidates = candidates
if not os.path.exists(working_dir + '/candidates'):
os.mkdir(working_dir + '/candidates')
deletion_candidate_output = open(working_dir + '/candidates/candidates_deletions.bed', 'w')
inversion_candidate_output = open(working_dir + '/candidates/candidates_inversions.bed', 'w')
tandem_duplication_candidate_source_output = open(working_dir + '/candidates/candidates_tan_duplications_source.bed', 'w')
tandem_duplication_candidate_dest_output = open(working_dir + '/candidates/candidates_tan_duplications_dest.bed', 'w')
interspersed_duplication_candidate_source_output = open(working_dir + '/candidates/candidates_int_duplications_source.bed', 'w')
interspersed_duplication_candidate_dest_output = open(working_dir + '/candidates/candidates_int_duplications_dest.bed', 'w')
novel_insertion_candidate_output = open(working_dir + '/candidates/candidates_novel_insertions.bed', 'w')
breakend_candidate_output = open(working_dir + '/candidates/candidates_breakends.bed', 'w')
for candidate in deletion_candidates:
print(candidate.get_bed_entry(), file=deletion_candidate_output)
for candidate in int_duplication_candidates:
bed_entries = candidate.get_bed_entries()
print(bed_entries[0], file=interspersed_duplication_candidate_source_output)
print(bed_entries[1], file=interspersed_duplication_candidate_dest_output)
for candidate in inversion_candidates:
print(candidate.get_bed_entry(), file=inversion_candidate_output)
for candidate in tan_duplication_candidates:
bed_entries = candidate.get_bed_entries()
print(bed_entries[0], file=tandem_duplication_candidate_source_output)
print(bed_entries[1], file=tandem_duplication_candidate_dest_output)
for candidate in novel_insertion_candidates:
print(candidate.get_bed_entry(), file=novel_insertion_candidate_output)
for candidate in breakend_candidates:
bed_entries = candidate.get_bed_entries()
print(bed_entries[0], file=breakend_candidate_output)
print(bed_entries[1], file=breakend_candidate_output)
deletion_candidate_output.close()
inversion_candidate_output.close()
interspersed_duplication_candidate_source_output.close()
interspersed_duplication_candidate_dest_output.close()
tandem_duplication_candidate_source_output.close()
tandem_duplication_candidate_dest_output.close()
novel_insertion_candidate_output.close()
breakend_candidate_output.close()
def sorted_nicely(vcf_entries):
""" Sort the given vcf entries (in the form ((contig, start, end), vcf_string, sv_type)) in the way that humans expect.
e.g. chr10 comes after chr2
Algorithm adapted from https://blog.codinghorror.com/sorting-for-humans-natural-sort-order/"""
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
tuple_key = lambda entry: ( alphanum_key(str(entry[0][0])), entry[0][1], entry[0][2] )
return sorted(vcf_entries, key = tuple_key)
def write_final_vcf(int_duplication_candidates,
inversion_candidates,
tandem_duplication_candidates,
deletion_candidates,
novel_insertion_candidates,
breakend_candidates,
version,
contig_names,
contig_lengths,
types_to_output,
options):
vcf_output = open(options.working_dir + '/variants.vcf', 'w')
# Write header lines
print("##fileformat=VCFv4.2", file=vcf_output)
print("##fileDate={0}".format(time.strftime("%Y-%m-%d|%I:%M:%S%p|%Z|%z")), file=vcf_output)
print("##source=SVIM-v{0}".format(version), file=vcf_output)
for contig_name, contig_length in zip(contig_names, contig_lengths):
print("##contig=".format(contig_name, contig_length), file=vcf_output)
if "DEL" in types_to_output:
print("##ALT=", file=vcf_output)
if "INV" in types_to_output:
print("##ALT=", file=vcf_output)
if (not options.tandem_duplications_as_insertions and "DUP:TANDEM" in types_to_output) or \
(not options.interspersed_duplications_as_insertions and "DUP:INT" in types_to_output):
print("##ALT=", file=vcf_output)
if not options.tandem_duplications_as_insertions and "DUP:TANDEM" in types_to_output:
print("##ALT=", file=vcf_output)
if not options.interspersed_duplications_as_insertions and "DUP:INT" in types_to_output:
print("##ALT=", file=vcf_output)
if "INS" in types_to_output:
print("##ALT=", file=vcf_output)
if "BND" in types_to_output:
print("##ALT=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
print("##INFO=", file=vcf_output)
if options.insertion_sequences:
print("##INFO=", file=vcf_output)
if options.read_names:
print("##INFO=", file=vcf_output)
if options.zmws:
print("##INFO=", file=vcf_output)
print("##FILTER=", file=vcf_output)
print("##FILTER=", file=vcf_output)
print("##FORMAT=", file=vcf_output)
print("##FORMAT=", file=vcf_output)
print("##FORMAT=", file=vcf_output)
if not options.tandem_duplications_as_insertions and "DUP:TANDEM" in types_to_output:
print("##FORMAT=", file=vcf_output)
print("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\t" + options.sample, file=vcf_output)
# Open reference genome sequence file
sequence_alleles = not options.symbolic_alleles
if sequence_alleles:
try:
reference = FastaFile(options.genome)
except ValueError:
logging.warning("The given reference genome is missing an index file ({path}.fai). Sequence alleles cannot be retrieved.".format(options.genome))
sequence_alleles = False
except IOError:
logging.warning("The given reference genome is missing ({path}). Sequence alleles cannot be retrieved.".format(options.genome))
sequence_alleles = False
else:
reference = None
# Prepare VCF entries depending on command-line parameters
vcf_entries = []
if "DEL" in types_to_output:
for candidate in deletion_candidates:
vcf_entries.append((candidate.get_source(), candidate.get_vcf_entry(sequence_alleles, reference, options.read_names, options.zmws), "DEL"))
if "INV" in types_to_output:
for candidate in inversion_candidates:
vcf_entries.append((candidate.get_source(), candidate.get_vcf_entry(sequence_alleles, reference, options.read_names, options.zmws), "INV"))
if "INS" in types_to_output:
for candidate in novel_insertion_candidates:
vcf_entries.append((candidate.get_destination(), candidate.get_vcf_entry(sequence_alleles, reference, options.insertion_sequences, options.read_names, options.zmws), "INS"))
if options.tandem_duplications_as_insertions:
if "INS" in types_to_output:
for candidate in tandem_duplication_candidates:
vcf_entries.append((candidate.get_destination(), candidate.get_vcf_entry_as_ins(sequence_alleles, reference, options.read_names, options.zmws), "INS"))
else:
if "DUP:TANDEM" in types_to_output:
for candidate in tandem_duplication_candidates:
vcf_entries.append((candidate.get_source(), candidate.get_vcf_entry_as_dup(options.read_names, options.zmws), "DUP_TANDEM"))
if options.interspersed_duplications_as_insertions:
if "INS" in types_to_output:
for candidate in int_duplication_candidates:
vcf_entries.append((candidate.get_destination(), candidate.get_vcf_entry_as_ins(sequence_alleles, reference, options.read_names, options.zmws), "INS"))
else:
if "DUP:INT" in types_to_output:
for candidate in int_duplication_candidates:
vcf_entries.append((candidate.get_source(), candidate.get_vcf_entry_as_dup(options.read_names, options.zmws), "DUP_INT"))
if "BND" in types_to_output:
for candidate in breakend_candidates:
vcf_entries.append(((candidate.get_source()[0], candidate.get_source()[1], candidate.get_source()[1] + 1), candidate.get_vcf_entry(options.read_names, options.zmws), "BND"))
vcf_entries.append(((candidate.get_destination()[0], candidate.get_destination()[1], candidate.get_destination()[1] + 1), candidate.get_vcf_entry_reverse(options.read_names, options.zmws), "BND"))
if sequence_alleles:
reference.close()
# Sort and write entries to VCF
svtype_counter = defaultdict(int)
for source, entry, svtype in sorted_nicely(vcf_entries):
variant_id = "svim.{svtype}.{number}".format(svtype = svtype, number = svtype_counter[svtype] + 1)
entry_with_id = entry.replace("PLACEHOLDERFORID", variant_id, 1)
svtype_counter[svtype] += 1
print(entry_with_id, file=vcf_output)
vcf_output.close()
def generate_insertion_consensus(ins_cluster, reference, window_padding = 100, maximum_haplotype_length = 10000, allowed_size_deviation = 2.0):
#compute window containing all members of cluster
member_pos = [member.start for member in ins_cluster.members]
window_start = min(member_pos) - window_padding
window_end = max(member_pos) + window_padding
#construct haplotype sequences from all reads
haplotypes = []
for member in ins_cluster.members:
haplotype_sequence = reference.fetch(ins_cluster.contig, max(0, window_start), max(0, member.start)).upper()
haplotype_sequence += member.sequence.upper()
haplotype_sequence += reference.fetch(ins_cluster.contig, max(0, member.start), max(0, window_end)).upper()
haplotypes.append(haplotype_sequence)
largest_haplotype_length = max([len(h) for h in haplotypes])
if largest_haplotype_length > maximum_haplotype_length:
logging.info("Skipping consensus computation for insertion with haplotypes exceeding maximum length ({0} > {1})".format(largest_haplotype_length, maximum_haplotype_length))
return (1, ())
#compute consensus of all reads using SPOA
try:
consensus_reads, msa_reads = poa(haplotypes, algorithm=1, m=2, n=-4, g=-4, e=-2, q=-24, c=-1)
except MemoryError:
logging.warning("Error: spoa ran out of memory while computing a consensus sequence for a cluster of insertion signatures (size = {0}, maximum haplotype length = {1}).".format(ins_cluster.size, largest_haplotype_length))
return (2, ())
except ValueError as ve:
logging.warning("Error: spoa failed while computing a consensus sequence for a cluster of insertion signatures (size = {0}, maximum haplotype length = {1}): {2}".format(ins_cluster.size, largest_haplotype_length, ve))
return (2, ())
#re-align consensus sequence to reference sequence in the window
ref_sequence = reference.fetch(ins_cluster.contig, max(0, window_start), max(0, window_end)).upper()
try:
consensus_reads_ref, msa_reads_ref = poa([consensus_reads, ref_sequence], algorithm=1, m=2, n=-4, g=-4, e=-2, q=-24, c=-1)
except MemoryError:
logging.warning("Error: spoa ran out of memory while aligning the consensus sequence for a cluster of insertion signatures (size = {0}, maximum haplotype length = {1}).".format(ins_cluster.size, largest_haplotype_length))
return (2, ())
except ValueError as ve:
logging.warning("Error: spoa failed while aligning the consensus sequence for a cluster of insertion signatures (size = {0}, maximum haplotype length = {1}): {2}".format(ins_cluster.size, largest_haplotype_length, ve))
return (2, ())
#locate insertion relative to reference and check whether size is close to expected size
expected_size = ins_cluster.end - ins_cluster.start
matches = []
for match in re.finditer(r'-+', msa_reads_ref[1]):
match_size = match.end() - match.start()
size_ratio = max(match_size, expected_size) / min(match_size, expected_size)
matches.append((match.start(), match_size, size_ratio))
good_matches = [m for m in matches if m[2] < allowed_size_deviation]
if len(good_matches) == 0:
logging.info("Consensus failure (no suitable insertion found in realignment step). \
Expected size: {0}; Match sizes: {1}; Ref: {2}; Consensus: {3}".format(expected_size,
"/".join([str(m[1]) for m in matches]),
msa_reads_ref[1],
msa_reads_ref[0]))
return (3, ())
elif len(good_matches) == 1:
realigned_insertion_start = max(0, window_start) + good_matches[0][0]
realigned_insertion_size = good_matches[0][1]
insertion_consensus = msa_reads_ref[0][good_matches[0][0]:good_matches[0][0]+good_matches[0][1]]
logging.debug("Consensus success. Expected size: {0}; Consensus size: {1}; Consensus insertion: {2}".format(expected_size, realigned_insertion_size, insertion_consensus))
return (0, (realigned_insertion_start, realigned_insertion_size, insertion_consensus))
else:
logging.info("Consensus failure (multiple suitable insertions found in realignment step). \
Expected size: {0}; Match sizes: {1}; Ref: {2}; Consensus: {3}".format(expected_size,
"/".join([str(m[1]) for m in matches]),
msa_reads_ref[1],
msa_reads_ref[0]))
return (4, ())
def prepare_insertion_candidates(insertion_signature_clusters, options):
novel_insertion_candidates = []
if options.skip_consensus or ("sse4_1" not in get_cpu_info()["flags"]):
if options.skip_consensus:
logging.info("Skipping computation of insertion consensus sequences because of --skip_consensus flag.")
else:
logging.warning("Skipping computation of insertion consensus sequences "
"because CPU does not support SSE 4.1 instruction set.")
for ins_cluster in insertion_signature_clusters:
if ins_cluster.score > 0:
novel_insertion_candidates.append(CandidateNovelInsertion(ins_cluster.contig,
ins_cluster.start,
ins_cluster.end,
"",
ins_cluster.members,
ins_cluster.score,
ins_cluster.std_span,
ins_cluster.std_pos))
return novel_insertion_candidates
logging.info("Generating and realigning consensus sequence for insertions..")
with FastaFile(options.genome) as reference:
# 0-successful, 1-skipped, 2-failed, 3-no consensus, 4-multiple consensuses
status_counter = [0, 0, 0, 0, 0]
for ins_cluster in insertion_signature_clusters:
if ins_cluster.score > 0:
if len(ins_cluster.members) < 3:
novel_insertion_candidates.append(CandidateNovelInsertion(ins_cluster.contig,
ins_cluster.start,
ins_cluster.end,
ins_cluster.members[0].sequence,
ins_cluster.members,
ins_cluster.score,
ins_cluster.std_span,
ins_cluster.std_pos))
continue
status, consensus_result = generate_insertion_consensus(ins_cluster,
reference,
maximum_haplotype_length=options.max_consensus_length)
try:
status_counter[status] += 1
except KeyError:
logging.error("Unknown status {0} returned by consensus computation.".format(status))
continue
# Successful
if status == 0:
realigned_insertion_start, realigned_insertion_size, insertion_consensus = consensus_result
novel_insertion_candidates.append(CandidateNovelInsertion(ins_cluster.contig,
realigned_insertion_start,
realigned_insertion_start + realigned_insertion_size,
insertion_consensus,
ins_cluster.members,
ins_cluster.score,
ins_cluster.std_span,
ins_cluster.std_pos))
#Unsuccessful
else:
novel_insertion_candidates.append(CandidateNovelInsertion(ins_cluster.contig,
ins_cluster.start,
ins_cluster.end,
"",
ins_cluster.members,
ins_cluster.score,
ins_cluster.std_span,
ins_cluster.std_pos))
message = ("Generated and realigned consensus sequences for {0} insertions "
"({1} skipped, {2} failed with an error, {3} failed with no "
"consensus, {4} failed with multiple consensuses).")
logging.info(message.format(status_counter[0],
status_counter[1],
status_counter[2],
status_counter[3],
status_counter[4]))
return novel_insertion_candidates
def combine_clusters(signature_clusters, options):
deletion_signature_clusters, insertion_signature_clusters, inversion_signature_clusters, tandem_duplication_signature_clusters, insertion_from_signature_clusters, translocation_signature_clusters = signature_clusters
###############################
# Create inversion candidates #
###############################
inversion_candidates = []
for inv_cluster in inversion_signature_clusters:
inversion_candidates.append(CandidateInversion(inv_cluster.contig, inv_cluster.start, inv_cluster.end, inv_cluster.members, inv_cluster.score, inv_cluster.std_span, inv_cluster.std_pos))
########################################
# Create tandem duplication candidates #
########################################
tan_dup_candidates = []
for tan_dup_cluster in tandem_duplication_signature_clusters:
source_contig, source_start, source_end = tan_dup_cluster.get_source()
dest_contig, dest_start, dest_end = tan_dup_cluster.get_destination()
num_copies = int(round((dest_end - dest_start) / (source_end - source_start)))
fully_covered = True if sum([sig.fully_covered for sig in tan_dup_cluster.members]) else False
tan_dup_candidates.append(CandidateDuplicationTandem(tan_dup_cluster.source_contig, tan_dup_cluster.source_start, tan_dup_cluster.source_end, num_copies, fully_covered, tan_dup_cluster.members, tan_dup_cluster.score, tan_dup_cluster.std_span, tan_dup_cluster.std_pos))
#####################################
# Cluster translocation breakpoints #
#####################################
# Cluster translocations by contig and pos1
# logging.info("Cluster translocation breakpoints..")
# translocations_fwdfwd = [tra for tra in translocation_signature_clusters if tra.direction1 == "fwd" and tra.direction2 == "fwd"]
# translocations_revrev = [tra for tra in translocation_signature_clusters if tra.direction1 == "rev" and tra.direction2 == "rev"]
# translocations_fwdrev = [tra for tra in translocation_signature_clusters if tra.direction1 == "fwd" and tra.direction2 == "rev"]
# translocations_revfwd = [tra for tra in translocation_signature_clusters if tra.direction1 == "rev" and tra.direction2 == "fwd"]
# translocation_partitions_fwdfwd = form_partitions(translocations_fwdfwd, options.trans_partition_max_distance)
# translocation_partitions_revrev = form_partitions(translocations_revrev, options.trans_partition_max_distance)
# translocation_partitions_fwdrev = form_partitions(translocations_fwdrev, options.trans_partition_max_distance)
# translocation_partitions_revfwd = form_partitions(translocations_revfwd, options.trans_partition_max_distance)
##############################
# Create breakend candidates #
##############################
breakend_candidates = []
for tra_cluster in translocation_signature_clusters:
breakend_candidates.append(CandidateBreakend(tra_cluster.source_contig,
tra_cluster.source_start,
tra_cluster.direction1,
tra_cluster.dest_contig,
tra_cluster.dest_start,
tra_cluster.direction2,
tra_cluster.members,
tra_cluster.score,
tra_cluster.std_span,
tra_cluster.std_pos))
###################################################
# Merge translocation breakpoints with insertions #
###################################################
logging.info("Combine inserted regions with translocation breakpoints..")
new_insertion_from_clusters, inserted_regions_to_remove_1 = merge_translocations_at_insertions(translocation_signature_clusters, insertion_signature_clusters, options)
insertion_from_signature_clusters.extend(new_insertion_from_clusters)
############################################################################
# Create interspersed duplication candidates and flag cut&paste insertions #
############################################################################
logging.info("Create interspersed duplication candidates and flag cut&paste insertions..")
int_duplication_candidates = flag_cutpaste_candidates(insertion_from_signature_clusters, deletion_signature_clusters, options)
###################################
# Remove inserted region clusters #
###################################
#find all inserted regions overlapping interspersed duplication or tandem duplication candidates
int_duplication_iterator = iter(sorted(int_duplication_candidates, key=lambda cand: cand.get_destination()))
tan_duplication_iterator = iter(sorted(tan_dup_candidates, key=lambda cand: cand.get_destination()))
int_duplications_end = False
tan_duplications_end = False
inserted_regions_to_remove_2 = []
try:
current_int_duplication = next(int_duplication_iterator)
except StopIteration:
int_duplications_end = True
try:
current_tan_duplication = next(tan_duplication_iterator)
except StopIteration:
tan_duplications_end = True
for inserted_region_index, inserted_region in enumerate(insertion_signature_clusters):
contig1, start1, end1 = inserted_region.get_source()
length1 = end1 - start1
if not int_duplications_end:
contig2, start2, end2 = current_int_duplication.get_destination()
while contig2 < contig1 or (contig2 == contig1 and end2 < start1):
try:
current_int_duplication = next(int_duplication_iterator)
contig2, start2, end2 = current_int_duplication.get_destination()
except StopIteration:
int_duplications_end = True
break
if not int_duplications_end:
length2 = end2 - start2
#if overlapping interspersed duplication of similar length
if contig2 == contig1 and start2 < end1 and (length1 - length2) / max(length1, length2) < 0.2:
inserted_regions_to_remove_2.append(inserted_region_index)
else:
if not tan_duplications_end:
contig2, start2, end2 = current_tan_duplication.get_destination()
while contig2 < contig1 or (contig2 == contig1 and end2 < start1):
try:
current_tan_duplication = next(tan_duplication_iterator)
contig2, start2, end2 = current_tan_duplication.get_destination()
except StopIteration:
tan_duplications_end = True
break
if not tan_duplications_end:
length2 = end2 - start2
#if overlapping tandem duplication of similar length
if contig2 == contig1 and start2 < end1 and (length1 - length2) / max(length1, length2) < 0.2:
inserted_regions_to_remove_2.append(inserted_region_index)
# remove found inserted regions
all_inserted_regions_to_remove = sorted(list(set(inserted_regions_to_remove_1 + inserted_regions_to_remove_2)), reverse=True)
for ins_index in all_inserted_regions_to_remove:
del(insertion_signature_clusters[ins_index])
##############################
# Create deletion candidates #
##############################
deletion_candidates = []
for del_cluster in deletion_signature_clusters:
if del_cluster.score > 0:
deletion_candidates.append(CandidateDeletion(del_cluster.contig, del_cluster.start, del_cluster.end, del_cluster.members, del_cluster.score, del_cluster.std_span, del_cluster.std_pos))
#####################################
# Create novel insertion candidates #
#####################################
novel_insertion_candidates = prepare_insertion_candidates(insertion_signature_clusters, options)
######################
# Cluster candidates #
######################
logging.info("Cluster interspersed duplication candidates one more time..")
final_int_duplication_candidates = partition_and_cluster_candidates(int_duplication_candidates, options, "interspersed duplication candidates")
return (deletion_candidates, inversion_candidates, final_int_duplication_candidates, tan_dup_candidates, novel_insertion_candidates, breakend_candidates)
svim-2.0.0/src/svim/SVIM_alignment.py 0000664 0000000 0000000 00000006372 14063053413 0017431 0 ustar 00root root 0000000 0000000 import os
import logging
from subprocess import run, CalledProcessError
class ToolMissingError(Exception): pass
class AlignmentPipelineError(Exception): pass
def check_prereqisites(aligner):
devnull = open(os.devnull, 'w')
try:
run(['gunzip', '--help'], stdout=devnull, stderr=devnull, check=True)
run([aligner, '--help'], stdout=devnull, stderr=devnull, check=True)
run(['samtools', '--help'], stdout=devnull, stderr=devnull, check=True)
except FileNotFoundError as e:
raise ToolMissingError('The alignment pipeline cannot be started because {0} was not found. Is it installed and in the PATH?'.format(e.filename)) from e
except CalledProcessError as e:
raise ToolMissingError('The alignment pipeline cannot be started because {0} failed.'.format(" ".join(e.cmd))) from e
def run_alignment(working_dir, genome, reads_path, reads_type, cores, aligner, nanopore):
"""Align full reads with NGMLR or minimap2."""
check_prereqisites(aligner)
reads_file_prefix = os.path.splitext(os.path.basename(reads_path))[0]
full_aln = "{0}/{1}.{2}.coordsorted.bam".format(working_dir, reads_file_prefix, aligner)
full_aln_index = "{0}/{1}.{2}.coordsorted.bam.bai".format(working_dir, reads_file_prefix, aligner)
if not (os.path.exists(full_aln) & os.path.exists(full_aln_index)):
try:
command_align = ['set', '-o', 'pipefail', '&&']
if aligner == "ngmlr":
# We need to uncompress gzipped files for NGMLR first
if reads_type == "fasta_gzip" or reads_type == "fastq_gzip":
command_align += ['gunzip', '-c', os.path.realpath(reads_path)]
command_align += ['|', 'ngmlr', '-t', str(cores), '-r', genome]
if nanopore:
command_align += ['-x', 'ont']
else:
command_align += ['ngmlr', '-t', str(cores), '-r', genome, '-q', os.path.realpath(reads_path)]
if nanopore:
command_align += ['-x', 'ont']
elif aligner == "minimap2":
if nanopore:
command_align += ['minimap2', '-t', str(cores), '-x', 'map-ont', '-a', genome, os.path.realpath(reads_path)]
else:
command_align += ['minimap2', '-t', str(cores), '-x', 'map-pb', '-a', genome, os.path.realpath(reads_path)]
command_align += ['|', 'samtools', 'view', '-b', '-@', str(cores)]
command_align += ['|', 'samtools', 'sort', '-@', str(cores), '-o', full_aln]
command_index = ['samtools', 'index', full_aln]
logging.info("Starting alignment pipeline..")
run(" ".join(command_align), shell=True, check=True, executable='/bin/bash')
run(" ".join(command_index), shell=True, check=True, executable='/bin/bash')
except CalledProcessError as e:
raise AlignmentPipelineError('The alignment pipeline failed with exit code {0}. Command was: {1}'.format(e.returncode, e.cmd)) from e
logging.info("Alignment pipeline finished")
return full_aln
else:
logging.warning("Alignment output file {0} already exists. Skip alignment and use the existing file.".format(full_aln))
return full_aln svim-2.0.0/src/svim/SVIM_clustering.py 0000664 0000000 0000000 00000056651 14063053413 0017637 0 ustar 00root root 0000000 0000000 from __future__ import print_function
import sys
import logging
from random import seed, sample
from statistics import mean, stdev
import numpy as np
from scipy.cluster.hierarchy import linkage, fcluster
from edlib import align
from pysam import FastaFile
from svim.SVSignature import SignatureClusterUniLocal, SignatureClusterBiLocal
from svim.SVCandidate import CandidateDuplicationInterspersed
def form_partitions(sv_signatures, max_distance):
"""Form partitions of signatures using mean distance."""
sorted_signatures = sorted(sv_signatures, key=lambda evi: evi.get_key())
partitions = []
current_partition = []
for signature in sorted_signatures:
if len(current_partition) > 0 and current_partition[-1].downstream_distance_to(signature) > max_distance:
partitions.append(current_partition[:])
current_partition = []
current_partition.append(signature)
if len(current_partition) > 0:
partitions.append(current_partition[:])
return partitions
def compute_haplotype_edit_distance(signature1, signature2, reference, window_padding = 100):
window_start = min(signature1.start, signature2.start) - window_padding
window_end = max(signature1.start, signature2.start) + window_padding
#construct haplotype sequences for both signatures
haplotype1 = reference.fetch(signature1.contig, max(0, window_start), max(0, signature1.start)).upper()
haplotype1 += signature1.sequence.upper()
haplotype1 += reference.fetch(signature1.contig, max(0, signature1.start), max(0, window_end)).upper()
haplotype2 = reference.fetch(signature2.contig, max(0, window_start), max(0, signature2.start)).upper()
haplotype2 += signature2.sequence.upper()
haplotype2 += reference.fetch(signature2.contig, max(0, signature2.start), max(0, window_end)).upper()
return align(haplotype1, haplotype2)["editDistance"]
def span_position_distance(signature1, signature2, signature_type, reference, position_distance_normalizer, edit_distance_normalizer, cluster_max_distance):
if signature_type == "DEL" or signature_type == "DUP_TAN":
span1 = signature1.get_source()[2] - signature1.get_source()[1]
span2 = signature2.get_source()[2] - signature2.get_source()[1]
center1 = (signature1.get_source()[1] + signature1.get_source()[2]) // 2
center2 = (signature2.get_source()[1] + signature2.get_source()[2]) // 2
position_distance = abs(center1 - center2) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance + span_distance
elif signature_type == "INV": #two signatures from same read can be clustered together"
span1 = signature1.get_source()[2] - signature1.get_source()[1]
span2 = signature2.get_source()[2] - signature2.get_source()[1]
center1 = (signature1.get_source()[1] + signature1.get_source()[2]) // 2
center2 = (signature2.get_source()[1] + signature2.get_source()[2]) // 2
position_distance = abs(center1 - center2) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance + span_distance
elif signature_type == "INS": #center is the insertion location
span1 = signature1.get_source()[2] - signature1.get_source()[1]
span2 = signature2.get_source()[2] - signature2.get_source()[1]
center1 = signature1.get_source()[1]
center2 = signature2.get_source()[1]
position_distance = abs(center1 - center2) / position_distance_normalizer
if position_distance > 2*cluster_max_distance:
#do not compute edit distance if insertions are too distant
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance + span_distance
else:
edit_distance = compute_haplotype_edit_distance(signature1, signature2, reference)
sequence_distance = edit_distance / max(span1, span2) / edit_distance_normalizer
return position_distance + sequence_distance
elif signature_type == "DUP_INT": #position distance is computed for source and destination
span1 = signature1.get_source()[2] - signature1.get_source()[1]
span2 = signature2.get_source()[2] - signature2.get_source()[1]
source_center1 = (signature1.get_source()[1] + signature1.get_source()[2]) // 2
source_center2 = (signature2.get_source()[1] + signature2.get_source()[2]) // 2
position_distance_source = abs(source_center1 - source_center2) / position_distance_normalizer
position_distance_destination = abs(signature1.get_destination()[1] - signature2.get_destination()[1]) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance_source + position_distance_destination + span_distance
elif signature_type == "BND": #only position distance is computed
dist1 = abs(signature1.get_source()[1] - signature2.get_source()[1])
dist2 = abs(signature1.get_destination()[1] - signature2.get_destination()[1])
if signature1.direction1 == signature2.direction1 and signature1.direction2 == signature2.direction2:
position_distance = (dist1 + dist2) / 3000
else:
position_distance = 99999
return position_distance
else:
return None
def span_position_distance_clusters(cluster1, cluster2, position_distance_normalizer):
"Span position distance function for merging clusters"
span1 = cluster1.get_source()[2] - cluster1.get_source()[1]
span2 = cluster2.get_source()[2] - cluster2.get_source()[1]
center1 = (cluster1.get_source()[1] + cluster1.get_source()[2]) // 2
center2 = (cluster2.get_source()[1] + cluster2.get_source()[2]) // 2
position_distance = abs(center1 - center2) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance + span_distance
def span_position_distance_intdup_candidates(signature1, signature2, position_distance_normalizer):
"Span position distance function for clustering candidates"
span1 = signature1.get_source()[2] - signature1.get_source()[1]
span2 = signature2.get_source()[2] - signature2.get_source()[1]
source_center1 = (signature1.get_source()[1] + signature1.get_source()[2]) // 2
source_center2 = (signature2.get_source()[1] + signature2.get_source()[2]) // 2
position_distance_source = abs(source_center1 - source_center2) / position_distance_normalizer
position_distance_destination = abs(signature1.get_destination()[1] - signature2.get_destination()[1]) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance_source + position_distance_destination + span_distance
def clusters_from_partitions(partitions, reference, options):
"""Finds clusters in partitions using span-position distance and hierarchical clustering.
Assumes that all signatures in the given partition are of the same type and on the same contig"""
clusters_final = []
large_partitions = 0
duplicate_signatures = 0
#initialize random number generator with fixed number to produce same output from same input
seed(1524)
# Find clusters in each partition individually.
for partition in partitions:
if len(partition) > 100:
partition_sample = sample(partition, 100)
large_partitions += 1
else:
partition_sample = partition
element_type = partition_sample[0].type
assert(element_type in ["DEL", "DUP_TAN", "INV", "INS", "DUP_INT", "BND"])
#remove similar signatures coming from the same read
if element_type == "INV":
#no duplication removal for inversions because they consist of two complementary signatures from the same read
partition_sample_without_duplicates = partition_sample
else:
duplicates_from_same_read = set()
for i in range(len(partition_sample)-1):
for j in range(i+1, len(partition_sample)):
if partition_sample[i].read == partition_sample[j].read and span_position_distance(partition_sample[i], partition_sample[j], element_type, reference, options.position_distance_normalizer, options.edit_distance_normalizer, options.cluster_max_distance) <= options.cluster_max_distance:
duplicates_from_same_read.add(j)
duplicate_signatures += len(duplicates_from_same_read)
partition_sample_without_duplicates = [partition_sample[i] for i in range(len(partition_sample)) if i not in duplicates_from_same_read]
if len(partition_sample_without_duplicates) == 1:
clusters_final.append([partition_sample_without_duplicates[0]])
continue
#compute pairwise distances
distances = []
if element_type == "INV":
for i in range(len(partition_sample_without_duplicates)-1):
for j in range(i+1, len(partition_sample_without_duplicates)):
distances.append(span_position_distance(partition_sample_without_duplicates[i], partition_sample_without_duplicates[j], element_type, reference, options.position_distance_normalizer, options.edit_distance_normalizer, options.cluster_max_distance))
else:
for i in range(len(partition_sample_without_duplicates)-1):
for j in range(i+1, len(partition_sample_without_duplicates)):
if partition_sample_without_duplicates[i].read == partition_sample_without_duplicates[j].read:
distances.append(99999)
else:
distances.append(span_position_distance(partition_sample_without_duplicates[i], partition_sample_without_duplicates[j], element_type, reference, options.position_distance_normalizer, options.edit_distance_normalizer, options.cluster_max_distance))
Z = linkage(np.array(distances), method = "average")
cluster_indices = list(fcluster(Z, options.cluster_max_distance, criterion='distance'))
new_clusters = [[] for i in range(max(cluster_indices))]
for signature_index, cluster_index in enumerate(cluster_indices):
new_clusters[cluster_index-1].append(partition_sample_without_duplicates[signature_index])
clusters_final.extend(new_clusters)
if len(partitions) > 0:
if len(partitions[0]) > 0:
logging.debug("%d out of %d partitions for %s exceeded 100 elements." % (large_partitions, len(partitions), partitions[0][0].type))
logging.debug("%d %s signatures were removed due to similarity to another signature from the same read." % (duplicate_signatures, partitions[0][0].type))
return clusters_final
def calculate_score(cluster, std_span, std_pos, span, type):
if std_span == None or std_pos == None:
span_deviation_score = 0
pos_deviation_score = 0
else:
span_deviation_score = 1 - min(1, std_span / span)
pos_deviation_score = 1 - min(1, std_pos / span)
if type == "INV":
directions = [signature.direction for signature in cluster]
direction_counts = [0, 0, 0, 0, 0]
for direction in directions:
if direction == "left_fwd":
direction_counts[0] += 1
if direction == "left_rev":
direction_counts[1] += 1
if direction == "right_fwd":
direction_counts[2] += 1
if direction == "right_rev":
direction_counts[3] += 1
if direction == "all":
direction_counts[4] += 1
left_signatures = direction_counts[0] + direction_counts[1]
right_signatures = direction_counts[2] + direction_counts[3]
valid_signatures = min(left_signatures, right_signatures) + direction_counts[4]
num_signatures = min(80, valid_signatures)
else:
num_signatures = min(80, len(cluster))
return num_signatures + span_deviation_score * (num_signatures / 8) + pos_deviation_score * (num_signatures / 8)
def consolidate_clusters_unilocal(clusters):
"""Consolidate clusters to a list of (type, contig, mean start, mean end, cluster size, members) tuples."""
consolidated_clusters = []
for cluster in clusters:
average_start = sum([member.get_source()[1] for member in cluster]) / len(cluster)
average_end = sum([member.get_source()[2] for member in cluster]) / len(cluster)
if len(cluster) > 1:
std_span = stdev([member.get_source()[2] - member.get_source()[1] for member in cluster])
std_pos = stdev([(member.get_source()[2] + member.get_source()[1]) / 2 for member in cluster])
else:
std_span = None
std_pos = None
score = calculate_score(cluster, std_span, std_pos, average_end - average_start, cluster[0].type)
consolidated_clusters.append(SignatureClusterUniLocal(cluster[0].get_source()[0], int(round(average_start)), int(round(average_end)), score, len(cluster), cluster, cluster[0].type, std_span, std_pos))
return consolidated_clusters
def consolidate_clusters_bilocal(clusters):
"""Consolidate clusters to a list of (type, contig, mean start, mean end, cluster size, members) tuples."""
consolidated_clusters = []
for cluster in clusters:
#Source
source_average_start = sum([member.get_source()[1] for member in cluster]) / len(cluster)
source_average_end = sum([member.get_source()[2] for member in cluster]) / len(cluster)
if len(cluster) > 1:
source_std_span = stdev([member.get_source()[2] - member.get_source()[1] for member in cluster])
source_std_pos = stdev([(member.get_source()[2] + member.get_source()[1]) / 2 for member in cluster])
else:
source_std_span = None
source_std_pos = None
if cluster[0].type == "DUP_TAN":
max_copies = max([member.copies for member in cluster])
score = calculate_score(cluster, source_std_span, source_std_pos, source_average_end - source_average_start, cluster[0].type)
consolidated_clusters.append(SignatureClusterBiLocal(cluster[0].get_source()[0],
int(round(source_average_start)),
int(round(source_average_end)),
cluster[0].get_source()[0],
int(round(source_average_end)),
int(round(source_average_end)) + max_copies *
(int(round(source_average_end)) -
int(round(source_average_start))),
score, len(cluster), cluster, cluster[0].type, source_std_span, source_std_pos))
elif cluster[0].type == "DUP_INT":
#Destination
destination_average_start = sum([member.get_destination()[1] for member in cluster]) / len(cluster)
destination_average_end = sum([member.get_destination()[2] for member in cluster]) / len(cluster)
if len(cluster) > 1:
destination_std_span = stdev([member.get_destination()[2] - member.get_destination()[1] for member in cluster])
destination_std_pos = stdev([(member.get_destination()[2] + member.get_destination()[1]) / 2 for member in cluster])
else:
destination_std_span = None
destination_std_pos = None
if source_std_span == None or source_std_pos == None or destination_std_span == None or destination_std_pos == None:
score = calculate_score(cluster, None, None, mean([source_average_end - source_average_start, destination_average_end - destination_average_start]), cluster[0].type)
consolidated_clusters.append(SignatureClusterBiLocal(cluster[0].get_source()[0], int(round(source_average_start)), int(round(source_average_end)),
cluster[0].get_destination()[0], int(round(destination_average_start)), int(round(destination_average_end)), score, len(cluster), cluster, cluster[0].type, None, None))
else:
score = calculate_score(cluster, mean([source_std_span, destination_std_span]), mean([source_std_pos, destination_std_pos]), mean([source_average_end - source_average_start, destination_average_end - destination_average_start]), cluster[0].type)
consolidated_clusters.append(SignatureClusterBiLocal(cluster[0].get_source()[0], int(round(source_average_start)), int(round(source_average_end)),
cluster[0].get_destination()[0], int(round(destination_average_start)), int(round(destination_average_end)), score, len(cluster), cluster, cluster[0].type, mean([source_std_span, destination_std_span]), mean([source_std_pos, destination_std_pos])))
elif cluster[0].type == "BND":
#Destination
destination_average_start = sum([member.get_destination()[1] for member in cluster]) / len(cluster)
destination_average_end = sum([member.get_destination()[2] for member in cluster]) / len(cluster)
#Directions
directions1 = list(set([member.direction1 for member in cluster]))
assert len(directions1) == 1
direction1 = directions1[0]
directions2 = list(set([member.direction2 for member in cluster]))
assert len(directions2) == 1
direction2 = directions2[0]
if len(cluster) > 1:
destination_std_pos = stdev([(member.get_destination()[2] + member.get_destination()[1]) / 2 for member in cluster])
else:
destination_std_span = None
destination_std_pos = None
if source_std_pos == None or destination_std_pos == None:
score = calculate_score(cluster, None, None, 500, cluster[0].type)
new_signature_cluster = SignatureClusterBiLocal(cluster[0].get_source()[0], int(round(source_average_start)), int(round(source_average_end)),
cluster[0].get_destination()[0], int(round(destination_average_start)), int(round(destination_average_end)), score, len(cluster), cluster, cluster[0].type, None, None)
else:
score = calculate_score(cluster, source_std_pos, destination_std_pos, 500, cluster[0].type)
new_signature_cluster = SignatureClusterBiLocal(cluster[0].get_source()[0], int(round(source_average_start)), int(round(source_average_end)),
cluster[0].get_destination()[0], int(round(destination_average_start)), int(round(destination_average_end)), score, len(cluster), cluster, cluster[0].type, source_std_pos, destination_std_pos)
new_signature_cluster.direction1 = direction1
new_signature_cluster.direction2 = direction2
consolidated_clusters.append(new_signature_cluster)
return consolidated_clusters
def partition_and_cluster_candidates(candidates, options, type):
partitions = form_partitions(candidates, options.partition_max_distance)
clusters = []
large_partitions = 0
#initialize random number generator with fixed number to produce same output from same input
seed(1524)
# Find clusters in each partition individually.
for partition in partitions:
if len(partition) == 1:
clusters.append([partition[0]])
continue
elif len(partition) > 100:
partition_sample = sample(partition, 100)
large_partitions += 1
else:
partition_sample = partition
element_type = partition_sample[0].type
distances = []
for i in range(len(partition_sample)-1):
for j in range(i+1, len(partition_sample)):
distances.append(span_position_distance_intdup_candidates(partition_sample[i], partition_sample[j], options.position_distance_normalizer))
Z = linkage(np.array(distances), method = "average")
cluster_indices = list(fcluster(Z, options.cluster_max_distance, criterion='distance'))
new_clusters = [[] for i in range(max(cluster_indices))]
for signature_index, cluster_index in enumerate(cluster_indices):
new_clusters[cluster_index-1].append(partition_sample[signature_index])
clusters.extend(new_clusters)
if len(partitions) > 0:
if len(partitions[0]) > 0:
logging.debug("%d out of %d partitions for %s exceeded 100 elements." % (large_partitions, len(partitions), partitions[0][0].type))
logging.info("Clustered {0}: {1} partitions and {2} clusters".format(type, len(partitions), len(clusters)))
final_candidates = []
for cluster in clusters:
combined_score = max([candidate.score for candidate in cluster])
combined_members = [member for candidate in cluster for member in candidate.members]
stds_span = [candidate.std_span for candidate in cluster if candidate.std_span != None]
if len(stds_span) >= 1:
combined_std_span = mean(stds_span)
else:
combined_std_span = None
stds_pos = [candidate.std_pos for candidate in cluster if candidate.std_pos != None]
if len(stds_pos) >= 1:
combined_std_pos = mean(stds_pos)
else:
combined_std_pos = None
#Source
source_average_start = (sum([candidate.get_source()[1] for candidate in cluster]) / len(cluster))
source_average_end = (sum([candidate.get_source()[2] for candidate in cluster]) / len(cluster))
#Destination
destination_average_start = (sum([candidate.get_destination()[1] for candidate in cluster]) / len(cluster))
destination_average_end = (sum([candidate.get_destination()[2] for candidate in cluster]) / len(cluster))
#Origin deleted?
cutpaste = False
for member in cluster:
if member.cutpaste:
cutpaste = True
if cluster[0].type == "DUP_INT":
final_candidates.append(CandidateDuplicationInterspersed(cluster[0].get_source()[0], int(round(source_average_start)), int(round(source_average_end)),
cluster[0].get_destination()[0], int(round(destination_average_start)), int(round(destination_average_end)), combined_members, combined_score, combined_std_span, combined_std_pos, cutpaste))
return final_candidates
def partition_and_cluster(signatures, options, type):
partitions = form_partitions(signatures, options.partition_max_distance)
with FastaFile(options.genome) as reference:
clusters = clusters_from_partitions(partitions, reference, options)
logging.info("Clustered {0}: {1} partitions and {2} clusters".format(type, len(partitions), len(clusters)))
if type == "deleted regions" or type == "inserted regions" or type == "inverted regions":
return sorted(consolidate_clusters_unilocal(clusters), key=lambda cluster: (cluster.contig, (cluster.end + cluster.start) / 2))
elif type == "tandem duplicated regions" or type == "inserted regions with detected region of origin" or type == "translocation breakpoints":
return consolidate_clusters_bilocal(clusters)
else:
logging.error("Unknown parameter type={0} to function partition_and_cluster.")
svim-2.0.0/src/svim/SVIM_genotyping.py 0000664 0000000 0000000 00000011311 14063053413 0017623 0 ustar 00root root 0000000 0000000 import time
import logging
from svim.SVIM_intra import analyze_alignment_indel
from svim.SVIM_inter import analyze_read_segments
from svim.SVIM_COLLECT import retrieve_other_alignments
def span_position_distance(candidate, signature, position_distance_normalizer):
if candidate.type == "INS" or candidate.type == "DUP_INT":
c_contig, c_start, c_end = candidate.get_destination()
else:
c_contig, c_start, c_end = candidate.get_source()
if signature.type == "DUP_INT":
s_contig, s_start, s_end = signature.get_destination()
else:
s_contig, s_start, s_end = signature.get_source()
#ins signatures can support dup_int candidates and vice versa
if not (candidate.type == "INS" and signature.type == "DUP_INT") and \
not (candidate.type == "DUP_INT" and signature.type == "INS") and \
candidate.type != signature.type:
return float("inf")
if c_contig != s_contig:
return float("inf")
span1 = c_end - c_start
span2 = s_end - s_start
center1 = (c_start + c_end) // 2
center2 = (s_start + s_end) // 2
position_distance = min(abs(c_start - s_start), abs(c_end - s_end), abs(center1 - center2)) / position_distance_normalizer
span_distance = abs(span1 - span2) / max(span1, span2)
return position_distance + span_distance
def genotype(candidates, bam, type, options):
num_candidates = len(candidates)
for nr, candidate in enumerate(candidates):
if (nr+1) % 10000 == 0:
logging.info("Processed {0} of {1} candidates".format(nr+1, num_candidates))
if candidate.score < options.minimum_score:
continue
#Fetch alignments around variant locus
if type == "INS" or type == "DUP_INT":
contig, start, end = candidate.get_destination()
#We need the insertion locus on the reference for which end is equal to start
end = start
else:
contig, start, end = candidate.get_source()
contig_length = bam.get_reference_length(contig)
alignment_it = bam.fetch(contig=contig, start=max(0, start-1000), stop=min(contig_length, end+1000))
reads_supporting_variant = set([sig.read for sig in candidate.members])
#Count reads that overlap the locus and therefore support the reference
reads_supporting_reference = set()
#Loop through fetched alignments
aln_no = 0
while aln_no < 500:
try:
current_alignment = next(alignment_it)
except StopIteration:
break
if current_alignment.query_name in reads_supporting_variant:
continue
if current_alignment.is_unmapped or current_alignment.is_secondary or current_alignment.mapping_quality < options.min_mapq:
continue
aln_no += 1
if type == "DEL" or type == "INV":
minimum_overlap = min((end - start) / 2, 2000)
if (current_alignment.reference_start < (end - minimum_overlap) and current_alignment.reference_end > (end + 100) or
current_alignment.reference_start < (start - 100) and current_alignment.reference_end > (start + minimum_overlap)):
reads_supporting_reference.add(current_alignment.query_name)
if type == "INS" or type == "DUP_INT":
if current_alignment.reference_start < (start - 100) and current_alignment.reference_end > (end + 100):
reads_supporting_reference.add(current_alignment.query_name)
if (len(reads_supporting_variant) + len(reads_supporting_reference)) >= options.minimum_depth:
candidate.support_fraction = len(reads_supporting_variant) / (len(reads_supporting_variant) + len(reads_supporting_reference))
if candidate.support_fraction >= options.homozygous_threshold:
candidate.genotype = "1/1"
elif candidate.support_fraction >= options.heterozygous_threshold and candidate.support_fraction < options.homozygous_threshold:
candidate.genotype = "0/1"
elif candidate.support_fraction < options.heterozygous_threshold:
candidate.genotype = "0/0"
else:
candidate.genotype = "./."
elif (len(reads_supporting_variant) + len(reads_supporting_reference)) > 0:
candidate.support_fraction = len(reads_supporting_variant) / (len(reads_supporting_variant) + len(reads_supporting_reference))
candidate.genotype = "./."
else:
candidate.support_fraction = "."
candidate.genotype = "./."
candidate.ref_reads = len(reads_supporting_reference)
candidate.alt_reads = len(reads_supporting_variant) svim-2.0.0/src/svim/SVIM_input_parsing.py 0000664 0000000 0000000 00000127475 14063053413 0020345 0 ustar 00root root 0000000 0000000 import sys
import os
import logging
import argparse
def parse_arguments(program_version, arguments = sys.argv[1:]):
parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
description="""SVIM (pronounced SWIM) is a structural variant caller for long reads.
It discriminates six different variant classes: deletions, tandem and interspersed duplications,
inversions, insertions and translocations. SVIM is unique in its capability of extracting both the genomic origin and
destination of duplications.
SVIM consists of four major steps:
- COLLECT detects signatures for SVs in long read alignments
- CLUSTER merges signatures that come from the same SV
- COMBINE combines clusters from different genomic regions and classifies them into distinct SV types
- GENOTYPE uses alignments spanning SVs to determine their genotype
SVIM can process two types of input. Firstly, it can detect SVs from raw reads by aligning them to a given reference genome first ("SVIM.py reads [options] working_dir reads genome").
Alternatively, it can detect SVs from existing reads alignments in SAM/BAM format ("SVIM.py alignment [options] working_dir bam_file").
""")
subparsers = parser.add_subparsers(help='modes', dest='sub')
parser.add_argument('--version',
'-v',
action='version',
version='%(prog)s {version}'.format(version=program_version))
parser_fasta = subparsers.add_parser('reads',
help='Detect SVs from raw reads. Align reads to given reference genome first.')
parser_fasta.add_argument('working_dir',
type=str,
help='Working and output directory. \
Existing files in the directory are overwritten. \
If the directory does not exist, it is created.')
parser_fasta.add_argument('reads',
type=str,
help='Read file (FASTA, FASTQ, gzipped FASTA, gzipped FASTQ or file list). \
The read file has to have one of the following supported file endings: \
FASTA: .fa, .fasta, .FA, .fa.gz, .fa.gzip, .fasta.gz, .fasta.gzip \
FASTQ: .fq, .fastq, .FQ, .fq.gz, .fq.gzip, .fastq.gz, .fastq.gzip \
FILE LIST: .fa.fn, fq.fn')
parser_fasta.add_argument('genome',
type=str,
help='Reference genome file (FASTA)')
parser_fasta.add_argument('--verbose',
action='store_true',
help='Enable more verbose logging (default: %(default)s)')
group_fasta_align = parser_fasta.add_argument_group('ALIGN')
group_fasta_align.add_argument('--cores',
type=int,
default=1,
help='CPU cores to use for the alignment (default: %(default)s)')
group_fasta_align.add_argument('--aligner',
type=str,
default="ngmlr",
choices=["ngmlr", "minimap2"],
help='Tool for read alignment: ngmlr or minimap2 (default: %(default)s)')
group_fasta_align.add_argument('--nanopore',
action='store_true',
help='Use Nanopore settings for read alignment (default: %(default)s)')
group_fasta_collect = parser_fasta.add_argument_group('COLLECT')
group_fasta_collect.add_argument('--min_mapq',
type=int,
default=20,
help='Minimum mapping quality of reads to consider (default: %(default)s). \
Reads with a lower mapping quality are ignored.')
group_fasta_collect.add_argument('--min_sv_size',
type=int,
default=40,
help='Minimum SV size to detect (default: %(default)s). \
SVIM can potentially detect events of any size but is limited by the \
signal-to-noise ratio in the input alignments. That means that more \
accurate reads and alignments enable the detection of smaller events. \
For current PacBio or Nanopore data, we would recommend a minimum size \
of 40bp or larger.')
group_fasta_collect.add_argument('--max_sv_size',
type=int,
default=100000,
help='Maximum SV size to detect (default: %(default)s). \
This parameter is used to distinguish long deletions (and inversions) from \
translocations which cannot be distinguished from the alignment alone. \
Split read segments mapping far apart on the reference could either \
indicate a very long deletion (inversion) or a translocation breakpoint. \
SVIM calls a translocation breakpoint if the mapping distance is larger \
than this parameter and a deletion (or inversion) if it is smaller or equal.')
group_fasta_collect.add_argument('--segment_gap_tolerance',
type=int,
default=10,
help='Maximum tolerated gap between adjacent alignment segments (default: %(default)s). \
This parameter applies to gaps on the reference and the read. Example: \
Deletions are detected from two subsequent segments of a split read that are mapped \
far apart from each other on the reference. The segment gap tolerance determines \
the maximum tolerated length of the read gap between both segments. If there is an \
unaligned read segment larger than this value between the two segments, no deletion is called.')
group_fasta_collect.add_argument('--segment_overlap_tolerance',
type=int,
default=5,
help='Maximum tolerated overlap between adjacent alignment segments (default: %(default)s). \
This parameter applies to overlaps on the reference and the read. Example: \
Deletions are detected from two subsequent segments of a split read that are mapped \
far apart from each other on the reference. The segment overlap tolerance determines \
the maximum tolerated length of an overlap between both segments on the read. If the \
overlap between the two segments on the read is larger than this value, no deletion is called.')
group_fasta_collect.add_argument('--all_bnds',
action='store_true',
help='Output all rearrangements additionally in BND notation (default: %(default)s). \
By default, SV signatures from the read alignments are used to detect complete SVs, \
such as deletions, insertions and inversions. When this option is enabled, all SVs \
are also output in breakend (BND) notation as defined in the VCF specs. For instance, \
a deletion gets two records in the VCF output: 1. the normal record and 2. \
a record representing the novel adjacency between the deletion\'s start and \
end coordinate in the sample genome.')
group_fasta_cluster = parser_fasta.add_argument_group('CLUSTER')
group_fasta_cluster.add_argument('--partition_max_distance',
type=int,
default=1000,
help='Maximum distance in bp between SVs in a partition (default: %(default)s). \
Before clustering, the SV signatures are divided into coarse partitions. This parameter \
determines the maximum distance between two subsequent signatures in the same partition. \
If the distance between two subsequent signatures \
is larger than this parameter, they are distributed into separate partitions.')
group_fasta_cluster.add_argument('--position_distance_normalizer',
type=int,
default=900,
help='Distance normalizer used for span-position distance (default: %(default)s). \
SVIM clusters the SV signatures using an hierarchical clustering approach and a \
novel distance metric called \"span-position distance\". Span-position distance \
is the sum of two components, span distance and position distance. \
The span distance is the difference in lengths between signatures normalized \
by the greater length and always lies in the interval [0,1]. \
The position distance is the difference in position between signatures \
normalized by the distance normalizer (this parameter). For a position difference \
of 1.8kb and a distance normalizer of 900, the position distance will be 2. \
A smaller distance normalizer leads to a higher position distance and as a \
consequence increases the importance of the position distance in the \
span-position distance relative to the span distance.')
group_fasta_cluster.add_argument('--edit_distance_normalizer',
type=float,
default=1.0,
help='Distance normalizer used specifically for insertions (default: %(default)s). \
SVIM clusters insertion signatures using an hierarchical clustering approach and a \
special distance metric for insertions. This distance is the sum of two \
components, position distance and edit distance between the insertion sequences. \
The edit distance is normalized (i.e. divided) by the product of the span of the \
longer insertion and this normalizer. The position distance is the difference in \
position between signatures normalized by the position distance normalizer \
(another parameter). A smaller edit distance normalizer leads to a larger \
edit distance and as a consequence increases the importance of the edit distance \
in the clustering process so that only insertions with very similar sequences \
are clustered together. A larger edit distance normalizer diminishes the importance \
of the insertion sequences in the clustering process.')
group_fasta_cluster.add_argument('--cluster_max_distance',
type=float,
default=0.5,
help='Maximum span-position distance between SVs in a cluster (default: %(default)s). \
This is the most important parameter because it determines the strictness \
of clustering. Choosing a large value leads to fewer but larger clusters with larger \
distances between its members. Choosing a small value leads to more but smaller \
clusters with smaller distances between its members. \
This parameter determines the height of the cut-off in the hierarchical clustering \
dendrogram.')
group_fasta_combine = parser_fasta.add_argument_group('COMBINE')
group_fasta_combine.add_argument('--del_ins_dup_max_distance',
type=float,
default=1.0,
help='Maximum span-position distance between the origin of an insertion and a deletion to be flagged as a potential cut&paste insertion (default: %(default)s)')
group_fasta_combine.add_argument('--trans_sv_max_distance',
type=int,
default=500,
help='Maximum distance in bp between a translocation breakpoint and an SV signature to be combined (default: %(default)s)')
group_fasta_combine.add_argument('--skip_consensus',
action='store_true',
help='Disable consensus computation for insertions (default: %(default)s). \
This reduces the time and memory consumption of SVIM and might be \
useful if consensus sequences are not needed. With this option, \
insertion calls are represented by symbolic alleles () instead \
of sequence alles in the output VCF. \
Consensus computation requires a modern CPU with the SSE 4.1 \
instruction set. For older CPUs missing this instruction set, \
consensus computation is automatically disabled.')
group_fasta_combine.add_argument('--max_consensus_length',
type=int,
default=10000,
help='Maximum size of insertion sequences for consensus computation. (default: %(default)s)\
For insertions longer than this threshold, no consensus is computed to save memory.')
group_fasta_genotype = parser_fasta.add_argument_group('GENOTYPE')
group_fasta_genotype.add_argument('--skip_genotyping',
action='store_true',
help='Disable genotyping (default: %(default)s)')
group_fasta_genotype.add_argument('--minimum_score',
type=int,
default=3,
help='Minimum score for genotyping (default: %(default)s). \
Only SV candidates with a higher or equal score are genotyped. Depending on the \
score distribution among the SV candidates, decreasing this value increases the \
runtime. We recommend to choose a value close to the score threshold used \
for filtering the SV candidates.')
group_fasta_genotype.add_argument('--homozygous_threshold',
type=float,
default=0.8,
help='Minimum variant allele frequency to be called as homozygous (default: %(default)s). \
Allele frequency is computed as the fraction of reads supporting the variant over the \
total number of reads covering the variant. Variants with an allele frequence greater \
than or equal to this threshold are called as homozygous alternative.')
group_fasta_genotype.add_argument('--heterozygous_threshold',
type=float,
default=0.2,
help='Minimum variant allele frequency to be called as heterozygous (default: %(default)s). \
Allele frequency is computed as the fraction of reads supporting the variant over the \
total number of reads covering the variant. Variants with an allele frequence greater \
than or equal to this threshold but lower than the homozygous threshold are called as \
heterozygous alternative. Variants with an allele frequence lower than this threshold \
are called as homozygous reference.')
group_fasta_genotype.add_argument('--minimum_depth',
type=int,
default=4,
help='Minimum total read depth for genotyping (default: %(default)s). \
Variants covered by a total number of reads lower than this value are not assigned \
a genotype (./. in the output VCF file).')
group_fasta_output = parser_fasta.add_argument_group('OUTPUT')
group_fasta_output.add_argument('--sample',
type=str,
default="Sample",
help='Sample ID to include in output vcf file (default: %(default)s)')
group_fasta_output.add_argument('--types',
type=str,
default="DEL,INS,INV,DUP:TANDEM,DUP:INT,BND",
help='SV types to include in output VCF (default: %(default)s). \
Give a comma-separated list of SV types. The possible SV types are: DEL (deletions), \
INS (novel insertions), INV (inversions), DUP:TANDEM (tandem duplications), \
DUP:INT (interspersed duplications), BND (breakends).')
group_fasta_output.add_argument('--symbolic_alleles',
action='store_true',
help='Use symbolic alleles, such as or in output VCF (default: %(default)s). \
By default, all SV alleles are represented by nucleotide sequences.')
group_fasta_output.add_argument('--insertion_sequences',
action='store_true',
help='Output insertion sequences in INFO tag of VCF (default: %(default)s). \
If enabled, the INFO/SEQS tag contains a list of insertion sequences from the supporting reads.')
group_fasta_output.add_argument('--tandem_duplications_as_insertions',
action='store_true',
help='Represent tandem duplications as insertions in output VCF (default: %(default)s). \
By default, tandem duplications are represented by the SVTYPE=DUP:TANDEM and the genomic source is given by the \
POS and END tags. When enabling this option, duplications are instead represented by the SVTYPE=INS \
and POS and END both give the insertion point of the duplication.')
group_fasta_output.add_argument('--interspersed_duplications_as_insertions',
action='store_true',
help='Represent interspersed duplications as insertions in output VCF (default: %(default)s). \
By default, interspersed duplications are represented by the SVTYPE=DUP:INT and the genomic source is given by the \
POS and END tags. When enabling this option, duplications are instead represented by the SVTYPE=INS \
and POS and END both give the insertion point of the duplication.')
group_fasta_output.add_argument('--read_names',
action='store_true',
help='Output names of supporting reads in INFO tag of VCF (default: %(default)s). \
If enabled, the INFO/READS tag contains the list of names of the supporting reads.')
group_fasta_output.add_argument('--zmws',
action='store_true',
help='look for information on ZMWs in PacBio read names (default: %(default)s). \
If enabled, the INFO/ZMWS tag contains the number of ZMWs that produced supporting reads.')
parser_bam = subparsers.add_parser('alignment',
help='Detect SVs from an existing alignment')
parser_bam.add_argument('working_dir',
type=os.path.abspath,
help='Working and output directory. \
Existing files in the directory are overwritten. \
If the directory does not exist, it is created.')
parser_bam.add_argument('bam_file',
type=str,
help='Coordinate-sorted and indexed BAM file with aligned long reads')
parser_bam.add_argument('genome',
type=str,
help='Reference genome file that the long reads were aligned to (FASTA)')
parser_bam.add_argument('--verbose',
action='store_true',
help='Enable more verbose logging (default: %(default)s)')
group_bam_collect = parser_bam.add_argument_group('COLLECT')
group_bam_collect.add_argument('--min_mapq',
type=int,
default=20,
help='Minimum mapping quality of reads to consider (default: %(default)s). \
Reads with a lower mapping quality are ignored.')
group_bam_collect.add_argument('--min_sv_size',
type=int,
default=40,
help='Minimum SV size to detect (default: %(default)s). \
SVIM can potentially detect events of any size but is limited by the \
signal-to-noise ratio in the input alignments. That means that more \
accurate reads and alignments enable the detection of smaller events. \
For current PacBio or Nanopore data, we would recommend a minimum size \
of 40bp or larger.')
group_bam_collect.add_argument('--max_sv_size',
type=int,
default=100000,
help='Maximum SV size to detect (default: %(default)s). \
This parameter is used to distinguish long deletions (and inversions) from \
translocations which cannot be distinguished from the alignment alone. \
Split read segments mapping far apart on the reference could either \
indicate a very long deletion (inversion) or a translocation breakpoint. \
SVIM calls a translocation breakpoint if the mapping distance is larger \
than this parameter and a deletion (or inversion) if it is smaller or equal.')
group_bam_collect.add_argument('--segment_gap_tolerance',
type=int,
default=10,
help='Maximum tolerated gap between adjacent alignment segments (default: %(default)s). \
This parameter applies to gaps on the reference and the read. Example: \
Deletions are detected from two subsequent segments of a split read that are mapped \
far apart from each other on the reference. The segment gap tolerance determines \
the maximum tolerated length of the read gap between both segments. If there is an \
unaligned read segment larger than this value between the two segments, no deletion is called.')
group_bam_collect.add_argument('--segment_overlap_tolerance',
type=int,
default=5,
help='Maximum tolerated overlap between adjacent alignment segments (default: %(default)s). \
This parameter applies to overlaps on the reference and the read. Example: \
Deletions are detected from two subsequent segments of a split read that are mapped \
far apart from each other on the reference. The segment overlap tolerance determines \
the maximum tolerated length of an overlap between both segments on the read. If the \
overlap between the two segments on the read is larger than this value, no deletion is called.')
group_bam_cluster = parser_bam.add_argument_group('CLUSTER')
group_bam_cluster.add_argument('--partition_max_distance',
type=int,
default=1000,
help='Maximum distance in bp between SVs in a partition (default: %(default)s). \
Before clustering, the SV signatures are divided into coarse partitions. This parameter \
determines the maximum distance between two subsequent signatures in the same partition. \
If the distance between two subsequent signatures \
is larger than this parameter, they are distributed into separate partitions.')
group_bam_cluster.add_argument('--position_distance_normalizer',
type=int,
default=900,
help='Distance normalizer used for span-position distance (default: %(default)s). \
SVIM clusters the SV signatures using an hierarchical clustering approach and a \
novel distance metric called \"span-position distance\". Span-position distance \
is the sum of two components, span distance and position distance. \
The span distance is the difference in lengths between signatures normalized \
by the greater length and always lies in the interval [0,1]. \
The position distance is the difference in position between signatures \
normalized by the distance normalizer (this parameter). For a position difference \
of 1.8kb and a distance normalizer of 900, the position distance will be 2. \
A smaller distance normalizer leads to a higher position distance and as a \
consequence increases the importance of the position distance in the \
span-position distance relative to the span distance.')
group_bam_cluster.add_argument('--edit_distance_normalizer',
type=float,
default=1.0,
help='Distance normalizer used specifically for insertions (default: %(default)s). \
SVIM clusters insertion signatures using an hierarchical clustering approach and a \
special distance metric for insertions. This distance is the sum of two \
components, position distance and edit distance between the insertion sequences. \
The edit distance is normalized (i.e. divided) by the product of the span of the \
longer insertion and this normalizer. The position distance is the difference in \
position between signatures normalized by the position distance normalizer \
(another parameter). A smaller edit distance normalizer leads to a larger \
edit distance and as a consequence increases the importance of the edit distance \
in the clustering process so that only insertions with very similar sequences \
are clustered together. A larger edit distance normalizer diminishes the importance \
of the insertion sequences in the clustering process.')
group_bam_cluster.add_argument('--cluster_max_distance',
type=float,
default=0.5,
help='Maximum span-position distance between SVs in a cluster (default: %(default)s). \
This is the most important parameter because it determines the strictness \
of clustering. Choosing a large value leads to fewer but larger clusters with larger \
distances between its members. Choosing a small value leads to more but smaller \
clusters with smaller distances between its members. \
This parameter determines the height of the cut-off in the hierarchical clustering \
dendrogram.')
group_bam_cluster.add_argument('--all_bnds',
action='store_true',
help='Output all rearrangements additionally in BND notation (default: %(default)s). \
By default, SV signatures from the read alignments are used to detect complete SVs, \
such as deletions, insertions and inversions. When this option is enabled, all SVs \
are also output in breakend (BND) notation as defined in the VCF specs. For instance, \
a deletion gets two records in the VCF output: 1. the normal record and 2. \
a record representing the novel adjacency between the deletion\'s start and \
end coordinate in the sample genome.')
group_bam_combine = parser_bam.add_argument_group('COMBINE')
group_bam_combine.add_argument('--del_ins_dup_max_distance',
type=float,
default=1.0,
help='Maximum span-position distance between the origin of an insertion and a deletion to be flagged as a potential cut&paste insertion (default: %(default)s)')
group_bam_combine.add_argument('--trans_sv_max_distance',
type=int,
default=500,
help='Maximum distance in bp between a translocation breakpoint and an SV signature to be combined (default: %(default)s)')
group_bam_combine.add_argument('--skip_consensus',
action='store_true',
help='Disable consensus computation for insertions (default: %(default)s). \
This reduces the time and memory consumption of SVIM and might be \
useful if consensus sequences are not needed. With this option, \
insertion calls are represented by symbolic alleles () instead \
of sequence alles in the output VCF. \
Consensus computation requires a modern CPU with the SSE 4.1 \
instruction set. For older CPUs missing this instruction set, \
consensus computation is automatically disabled.')
group_bam_combine.add_argument('--max_consensus_length',
type=int,
default=10000,
help='Maximum size of insertion sequences for consensus computation. (default: %(default)s)\
For insertions longer than this threshold, no consensus is computed to save memory.')
group_bam_genotype = parser_bam.add_argument_group('GENOTYPE')
group_bam_genotype.add_argument('--skip_genotyping',
action='store_true',
help='Disable genotyping (default: %(default)s)')
group_bam_genotype.add_argument('--minimum_score',
type=int,
default=3,
help='Minimum score for genotyping (default: %(default)s). \
Only SV candidates with a higher or equal score are genotyped. Depending on the \
score distribution among the SV candidates, decreasing this value increases the \
runtime. We recommend to choose a value close to the score threshold used \
for filtering the SV candidates.')
group_bam_genotype.add_argument('--homozygous_threshold',
type=float,
default=0.8,
help='Minimum variant allele frequency to be called as homozygous (default: %(default)s). \
Allele frequency is computed as the fraction of reads supporting the variant over the \
total number of reads covering the variant. Variants with an allele frequence greater \
than or equal to this threshold are called as homozygous alternative.')
group_bam_genotype.add_argument('--heterozygous_threshold',
type=float,
default=0.2,
help='Minimum variant allele frequency to be called as heterozygous (default: %(default)s). \
Allele frequency is computed as the fraction of reads supporting the variant over the \
total number of reads covering the variant. Variants with an allele frequence greater \
than or equal to this threshold but lower than the homozygous threshold are called as \
heterozygous alternative. Variants with an allele frequence lower than this threshold \
are called as homozygous reference.')
group_bam_genotype.add_argument('--minimum_depth',
type=int,
default=4,
help='Minimum total read depth for genotyping (default: %(default)s). \
Variants covered by a total number of reads lower than this value are not assigned \
a genotype (./. in the output VCF file).')
group_bam_output = parser_bam.add_argument_group('OUTPUT')
group_bam_output.add_argument('--sample',
type=str,
default="Sample",
help='Sample ID to include in output vcf file (default: %(default)s)')
group_bam_output.add_argument('--types',
type=str,
default="DEL,INS,INV,DUP:TANDEM,DUP:INT,BND",
help='SV types to include in output VCF (default: %(default)s). \
Give a comma-separated list of SV types. The possible SV types are: DEL (deletions), \
INS (novel insertions), INV (inversions), DUP:TANDEM (tandem duplications), \
DUP:INT (interspersed duplications), BND (breakends).')
group_bam_output.add_argument('--symbolic_alleles',
action='store_true',
help='Use symbolic alleles, such as or in output VCF (default: %(default)s). \
By default, all SV alleles are represented by nucleotide sequences.')
group_bam_output.add_argument('--insertion_sequences',
action='store_true',
help='Output insertion sequences in INFO tag of VCF (default: %(default)s). \
If enabled, the INFO/SEQS tag contains a list of insertion sequences from the supporting reads.')
group_bam_output.add_argument('--tandem_duplications_as_insertions',
action='store_true',
help='Represent tandem duplications as insertions in output VCF (default: %(default)s). \
By default, tandem duplications are represented by the SVTYPE=DUP:TANDEM and the genomic source is given by the \
POS and END tags. When enabling this option, duplications are instead represented by the SVTYPE=INS \
and POS and END both give the insertion point of the duplication.')
group_bam_output.add_argument('--interspersed_duplications_as_insertions',
action='store_true',
help='Represent interspersed duplications as insertions in output VCF (default: %(default)s). \
By default, interspersed duplications are represented by the SVTYPE=DUP:INT and the genomic source is given by the \
POS and END tags. When enabling this option, duplications are instead represented by the SVTYPE=INS \
and POS and END both give the insertion point of the duplication.')
group_bam_output.add_argument('--read_names',
action='store_true',
help='Output names of supporting reads in INFO tag of VCF (default: %(default)s). \
If enabled, the INFO/READS tag contains the list of names of the supporting reads.')
group_bam_output.add_argument('--zmws',
action='store_true',
help='look for information on ZMWs in PacBio read names (default: %(default)s). \
If enabled, the INFO/ZMWS tag contains the number of ZMWs that produced supporting reads.')
return parser.parse_args(arguments)
def guess_file_type(reads_path):
if reads_path.endswith(".fa") or reads_path.endswith(".fasta") or reads_path.endswith(".FA"):
logging.info("Recognized reads file as FASTA format.")
return "fasta"
elif reads_path.endswith(".fq") or reads_path.endswith(".fastq") or reads_path.endswith(".FQ"):
logging.info("Recognized reads file as FASTQ format.")
return "fastq"
elif reads_path.endswith(".fa.gz") or reads_path.endswith(".fasta.gz") or reads_path.endswith(".FA.gz") or reads_path.endswith(".fa.gzip") or reads_path.endswith(".fasta.gzip") or reads_path.endswith(".FA.gzip"):
logging.info("Recognized reads file as gzipped FASTA format.")
return "fasta_gzip"
elif reads_path.endswith(".fq.gz") or reads_path.endswith(".fastq.gz") or reads_path.endswith(".FQ.gz") or reads_path.endswith(".fq.gzip") or reads_path.endswith(".fastq.gzip") or reads_path.endswith(".FQ.gzip"):
logging.info("Recognized reads file as gzipped FASTQ format.")
return "fastq_gzip"
elif reads_path.endswith(".fa.fn") or reads_path.endswith(".fasta.fn") or reads_path.endswith(".FA.fn") or reads_path.endswith(".fq.fn") or reads_path.endswith(".fastq.fn") or reads_path.endswith(".FQ.fn"):
logging.info("Recognized reads file as file list format.")
return "list"
else:
logging.error("Unknown file ending of file {0}. See github.com/eldariont/svim/wiki/ for supported file endings. Exiting.".format(reads_path))
return "unknown"
def read_file_list(path):
file_list = open(path, "r")
for line in file_list:
yield line.strip()
file_list.close() svim-2.0.0/src/svim/SVIM_inter.py 0000664 0000000 0000000 00000055467 14063053413 0016605 0 ustar 00root root 0000000 0000000 from __future__ import print_function
import sys
import logging
from statistics import mean
from svim.SVSignature import SignatureDeletion, SignatureInsertion, SignatureInversion, SignatureTranslocation, SignatureDuplicationTandem, SignatureInsertionFrom
from svim.SVIM_clustering import consolidate_clusters_bilocal, clusters_from_partitions
def is_similar(chr1, start1, end1, chr2, start2, end2, span_position_treshold = 0.3):
span1 = end1 - start1
span2 = end2 - start2
center1 = (start1 + end1) // 2
center2 = (start2 + end2) // 2
position_distance = abs(center1 - center2) / 900
span_distance = abs(span1 - span2) / max(span1, span2)
if chr1 == chr2 and position_distance + span_distance < span_position_treshold:
return True
else:
return False
def analyze_read_segments(primary, supplementaries, bam, options):
read_name = primary.query_name
alignments = [primary] + supplementaries
alignment_list = []
for alignment in alignments:
#correct query coordinates for reversely mapped reads
if alignment.is_reverse:
inferred_read_length = alignment.infer_read_length()
if inferred_read_length is None:
logging.warning('Skipping alignment because pysam was unable to infer length of read from CIGAR string (alignment.infer_read_length() returned None). Query name: {0}, CIGAR: {1}'.format(alignment.query_name, alignment.cigarstring))
continue
q_start = inferred_read_length - alignment.query_alignment_end
q_end = inferred_read_length - alignment.query_alignment_start
else:
q_start = alignment.query_alignment_start
q_end = alignment.query_alignment_end
new_alignment_dict = { 'q_start': q_start,
'q_end': q_end,
'ref_id': alignment.reference_id,
'ref_start': alignment.reference_start,
'ref_end': alignment.reference_end,
'is_reverse': alignment.is_reverse }
alignment_list.append(new_alignment_dict)
sorted_alignment_list = sorted(alignment_list, key=lambda aln: (aln['q_start'], aln['q_end']))
#inferred_read_length = alignments[0].infer_read_length()
sv_signatures = []
#Translocation signatures from other SV classes are stored separately for --all_bnd option
translocation_signatures_all_bnds = []
tandem_duplications = []
translocations = []
for index in range(len(sorted_alignment_list) - 1):
alignment_current = sorted_alignment_list[index]
alignment_next = sorted_alignment_list[index + 1]
distance_on_read = alignment_next['q_start'] - alignment_current['q_end']
#Same chromosome
if alignment_current['ref_id'] == alignment_next['ref_id']:
ref_chr = bam.getrname(alignment_current['ref_id'])
#Same orientation
if alignment_current['is_reverse'] == alignment_next['is_reverse']:
#Compute distance on reference depending on orientation
if alignment_current['is_reverse']:
distance_on_reference = alignment_current['ref_start'] - alignment_next['ref_end']
else:
distance_on_reference = alignment_next['ref_start'] - alignment_current['ref_end']
#No overlap on read
if distance_on_read >= -options.segment_overlap_tolerance:
#No overlap on reference
if distance_on_reference >= -options.segment_overlap_tolerance:
deviation = distance_on_read - distance_on_reference
#INS candidate
if deviation >= options.min_sv_size:
#No gap on reference
if distance_on_reference <= options.segment_gap_tolerance:
if not alignment_current['is_reverse']:
try:
insertion_seq = primary.query_sequence[alignment_current['q_end']:alignment_current['q_end']+deviation]
except TypeError:
insertion_seq = ""
sv_signatures.append(SignatureInsertion(ref_chr, alignment_current['ref_end'], alignment_current['ref_end'] + deviation, "suppl", read_name, insertion_seq))
else:
try:
insertion_seq = primary.query_sequence[primary.infer_read_length() - alignment_next['q_start']:primary.infer_read_length() - alignment_next['q_start'] + deviation]
except TypeError:
insertion_seq = ""
sv_signatures.append(SignatureInsertion(ref_chr, alignment_current['ref_start'], alignment_current['ref_start'] + deviation, "suppl", read_name, insertion_seq))
#DEL candidate
elif -options.max_sv_size <= deviation <= -options.min_sv_size:
#No gap on read
if distance_on_read <= options.segment_gap_tolerance:
if not alignment_current['is_reverse']:
sv_signatures.append(SignatureDeletion(ref_chr, alignment_current['ref_end'], alignment_current['ref_end'] - deviation, "suppl", read_name))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_current['ref_end'] - deviation, 'fwd', "suppl", read_name))
else:
sv_signatures.append(SignatureDeletion(ref_chr, alignment_next['ref_end'], alignment_next['ref_end'] - deviation, "suppl", read_name))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_next['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_end'] - deviation, 'fwd', "suppl", read_name))
#Either very large DEL or TRANS
elif deviation < -options.max_sv_size:
#No gap on read
if distance_on_read <= options.segment_gap_tolerance:
if not alignment_current['is_reverse']:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('fwd', 'fwd', ref_chr, alignment_current['ref_end'] - 1, ref_chr, alignment_next['ref_start']))
else:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('rev', 'rev', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_end'] - 1))
#overlap on reference
else:
#Tandem Duplication
if distance_on_reference <= -options.min_sv_size:
if not alignment_current['is_reverse']:
#Tandem Duplication
if alignment_next['ref_end'] > alignment_current['ref_start']:
tandem_duplications.append((ref_chr, alignment_next['ref_start'], alignment_current['ref_end'], True, True))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
#Large tandem duplication
elif distance_on_reference >= -options.max_sv_size:
tandem_duplications.append((ref_chr, alignment_next['ref_start'], alignment_current['ref_end'], False, True))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
#Either very large TANDEM or TRANS
else:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('fwd', 'fwd', ref_chr, alignment_current['ref_end'] - 1, ref_chr, alignment_next['ref_start']))
else:
#Tandem Duplication
if alignment_next['ref_start'] < alignment_current['ref_end']:
tandem_duplications.append((ref_chr, alignment_current['ref_start'], alignment_next['ref_end'], True, False))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
#Large tandem duplication
elif distance_on_reference >= -options.max_sv_size:
tandem_duplications.append((ref_chr, alignment_current['ref_start'], alignment_next['ref_end'], False, False))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
#Either very large TANDEM or TRANS
else:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('rev', 'rev', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_end'] - 1))
#Different orientations
else:
#Normal to reverse
if not alignment_current['is_reverse'] and alignment_next['is_reverse']:
if -options.segment_overlap_tolerance <= distance_on_read <= options.segment_gap_tolerance:
if alignment_next['ref_start'] - alignment_current['ref_end'] >= -options.segment_overlap_tolerance: # Case 1
#INV candidate
if options.min_sv_size <= alignment_next['ref_end'] - alignment_current['ref_end'] <= options.max_sv_size:
sv_signatures.append(SignatureInversion(ref_chr, alignment_current['ref_end'], alignment_next['ref_end'], "suppl", read_name, "left_fwd"))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
#Either very large INV or TRANS
elif alignment_next['ref_end'] - alignment_current['ref_end'] > options.max_sv_size:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('fwd', 'rev', ref_chr, alignment_current['ref_end'] - 1, ref_chr, alignment_next['ref_end'] - 1))
elif alignment_current['ref_start'] - alignment_next['ref_end'] >= -options.segment_overlap_tolerance: # Case 3
#INV candidate
if options.min_sv_size <= alignment_current['ref_end'] - alignment_next['ref_end'] <= options.max_sv_size:
sv_signatures.append(SignatureInversion(ref_chr, alignment_next['ref_end'], alignment_current['ref_end'], "suppl", read_name, "left_rev"))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
#Either very large INV or TRANS
elif alignment_current['ref_end'] - alignment_next['ref_end'] > options.max_sv_size:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_end'] - 1, 'fwd', ref_chr, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('fwd', 'rev', ref_chr, alignment_current['ref_end'] - 1, ref_chr, alignment_next['ref_end'] - 1))
else:
pass
#print("Overlapping read segments in read", read_name)
#Reverse to normal
if alignment_current['is_reverse'] and not alignment_next['is_reverse']:
if -options.segment_overlap_tolerance <= distance_on_read <= options.segment_gap_tolerance:
if alignment_next['ref_start'] - alignment_current['ref_end'] >= -options.segment_overlap_tolerance: # Case 2
#INV candidate
if options.min_sv_size <= alignment_next['ref_start'] - alignment_current['ref_start'] <= options.max_sv_size:
sv_signatures.append(SignatureInversion(ref_chr, alignment_current['ref_start'], alignment_next['ref_start'], "suppl", read_name, "right_fwd"))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
#Either very large INV or TRANS
elif alignment_next['ref_start'] - alignment_current['ref_start'] > options.max_sv_size:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('rev', 'fwd', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_start']))
elif alignment_current['ref_start'] - alignment_next['ref_end'] >= -options.segment_overlap_tolerance: # Case 4
#INV candidate
if options.min_sv_size <= alignment_current['ref_start'] - alignment_next['ref_start'] <= options.max_sv_size:
sv_signatures.append(SignatureInversion(ref_chr, alignment_next['ref_start'], alignment_current['ref_start'], "suppl", read_name, "right_rev"))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
#Either very large INV or TRANS
elif alignment_current['ref_start'] - alignment_next['ref_start'] > options.max_sv_size:
sv_signatures.append(SignatureTranslocation(ref_chr, alignment_current['ref_start'], 'rev', ref_chr, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('rev', 'fwd', ref_chr, alignment_current['ref_start'], ref_chr, alignment_next['ref_start']))
else:
pass
#print("Overlapping read segments in read", read_name)
#Different chromosomes
else:
ref_chr_current = bam.getrname(alignment_current['ref_id'])
ref_chr_next = bam.getrname(alignment_next['ref_id'])
#Same orientation
if alignment_current['is_reverse'] == alignment_next['is_reverse']:
#No overlap on read
if distance_on_read >= -options.segment_overlap_tolerance:
#No gap on read
if distance_on_read <= options.segment_gap_tolerance:
if not alignment_current['is_reverse']:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_end'] - 1, 'fwd', ref_chr_next, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('fwd', 'fwd', ref_chr_current, alignment_current['ref_end'] - 1, ref_chr_next, alignment_next['ref_start']))
else:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_start'], 'rev', ref_chr_next, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('rev', 'rev', ref_chr_current, alignment_current['ref_start'], ref_chr_next, alignment_next['ref_end'] - 1))
#Overlap on read
else:
pass
#print("Overlapping read segments in read", read_name)
#Different orientation
else:
#No overlap on read
if distance_on_read >= -options.segment_overlap_tolerance:
#No gap on read
if distance_on_read <= options.segment_gap_tolerance:
if not alignment_current['is_reverse']:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_end'] - 1, 'fwd', ref_chr_next, alignment_next['ref_end'] - 1, 'rev', "suppl", read_name))
translocations.append(('fwd', 'rev', ref_chr_current, alignment_current['ref_end'] - 1, ref_chr_next, alignment_next['ref_end'] - 1))
else:
sv_signatures.append(SignatureTranslocation(ref_chr_current, alignment_current['ref_start'], 'rev', ref_chr_next, alignment_next['ref_start'], 'fwd', "suppl", read_name))
translocations.append(('rev', 'fwd', ref_chr_current, alignment_current['ref_start'], ref_chr_next, alignment_next['ref_start']))
#Overlap on read
else:
pass
#print("Overlapping read segments in read", read_name)
#Handle tandem duplications
current_chromosome = None
current_starts = []
current_ends = []
current_copy_number = 0
current_fully_covered = []
for tandem_duplication in tandem_duplications:
if current_chromosome == None:
current_chromosome = tandem_duplication[0]
current_starts.append(tandem_duplication[1])
current_ends.append(tandem_duplication[2])
current_copy_number = 1
current_fully_covered.append(tandem_duplication[3])
current_direction = tandem_duplication[4]
else:
if is_similar(current_chromosome, mean(current_starts), mean(current_ends), tandem_duplication[0], tandem_duplication[1], tandem_duplication[2]) and current_direction == tandem_duplication[4]:
current_starts.append(tandem_duplication[1])
current_ends.append(tandem_duplication[2])
current_copy_number += 1
current_fully_covered.append(tandem_duplication[3])
else:
fully_covered = True if sum(current_fully_covered) else False
sv_signatures.append(SignatureDuplicationTandem(current_chromosome, int(mean(current_starts)), int(mean(current_ends)), current_copy_number, fully_covered, "suppl", read_name))
current_chromosome = tandem_duplication[0]
current_starts =[tandem_duplication[1]]
current_ends =[tandem_duplication[2]]
current_copy_number = 1
current_fully_covered = [tandem_duplication[3]]
if current_chromosome != None:
fully_covered = True if sum(current_fully_covered) else False
sv_signatures.append(SignatureDuplicationTandem(current_chromosome, int(mean(current_starts)), int(mean(current_ends)), current_copy_number, fully_covered, "suppl", read_name))
#Handle insertions_from
for this_index in range(len(translocations)):
this_dir1 = translocations[this_index][0]
this_dir2 = translocations[this_index][1]
this_chr1 = translocations[this_index][2]
this_pos1 = translocations[this_index][3]
this_chr2 = translocations[this_index][4]
this_pos2 = translocations[this_index][5]
for before_dir1, before_dir2, before_chr1, before_pos1, before_chr2, before_pos2 in translocations[:this_index]:
#Same direction at destination and origin
if before_dir1 == this_dir2 and before_dir2 == this_dir1:
#Same position at destination
if is_similar(before_chr1, before_pos1, before_pos1+1, this_chr2, this_pos2, this_pos2+1, span_position_treshold=0.1):
#Same chromosome for origin
if before_chr2 == this_chr1:
#INS_DUP candidate
if before_dir2 == before_dir1:
if before_dir1 == 'fwd':
if options.min_sv_size <= this_pos1 - before_pos2 + 1 <= options.max_sv_size:
sv_signatures.append(SignatureInsertionFrom(before_chr2, before_pos2, this_pos1 + 1, before_chr1, int(mean([before_pos1 + 1, this_pos2])), "suppl", read_name))
elif before_dir1 == 'rev':
if options.min_sv_size <= before_pos2 - this_pos1 <= options.max_sv_size:
sv_signatures.append(SignatureInsertionFrom(before_chr2, this_pos1, before_pos2 + 1, before_chr1, int(mean([before_pos1, this_pos2 + 1])), "suppl", read_name))
#INV_INS_DUP candidate
else:
pass
return sv_signatures, translocation_signatures_all_bnds
svim-2.0.0/src/svim/SVIM_intra.py 0000664 0000000 0000000 00000004445 14063053413 0016567 0 ustar 00root root 0000000 0000000 from __future__ import print_function
import sys
from svim.SVSignature import SignatureDeletion, SignatureInsertion, SignatureTranslocation
def analyze_cigar_indel(tuples, min_length):
"""Parses CIGAR tuples (op, len) and returns Indels with a length > minLength"""
pos_ref = 0
pos_read = 0
indels = []
for operation, length in tuples:
if operation == 0: # alignment match
pos_ref += length
pos_read += length
elif operation == 1: # insertion
if length >= min_length:
indels.append((pos_ref, pos_read, length, "INS"))
pos_read += length
elif operation == 2: # deletion
if length >= min_length:
indels.append((pos_ref, pos_read, length, "DEL"))
pos_ref += length
elif operation == 4: # soft clip
pos_read += length
elif operation == 7 or operation == 8: # match or mismatch
pos_ref += length
pos_read += length
return indels
def analyze_alignment_indel(alignment, bam, query_name, options):
sv_signatures = []
#Translocation signatures from other SV classes are stored separately for --all_bnd option
translocation_signatures_all_bnds = []
ref_chr = bam.getrname(alignment.reference_id)
ref_start = alignment.reference_start
indels = analyze_cigar_indel(alignment.cigartuples, options.min_sv_size)
for pos_ref, pos_read, length, typ in indels:
if typ == "DEL":
sv_signatures.append(SignatureDeletion(ref_chr, ref_start + pos_ref, ref_start + pos_ref + length, "cigar", query_name))
if options.all_bnds:
translocation_signatures_all_bnds.append(SignatureTranslocation(ref_chr, ref_start + pos_ref, 'fwd', ref_chr, ref_start + pos_ref + length, 'fwd', "cigar", query_name))
elif typ == "INS":
try:
insertion_seq = alignment.query_sequence[pos_read:pos_read+length]
except TypeError:
insertion_seq = ""
sv_signatures.append(SignatureInsertion(ref_chr, ref_start + pos_ref, ref_start + pos_ref + length, "cigar", query_name, insertion_seq))
return sv_signatures, translocation_signatures_all_bnds
svim-2.0.0/src/svim/SVIM_merging.py 0000664 0000000 0000000 00000024350 14063053413 0017077 0 ustar 00root root 0000000 0000000 from __future__ import print_function
import sys
from bisect import bisect_left
from collections import defaultdict
from math import pow, sqrt
from svim.SVSignature import SignatureTranslocation, SignatureInsertionFrom, SignatureClusterBiLocal
from svim.SVCandidate import CandidateDuplicationInterspersed
from svim.SVIM_clustering import span_position_distance_clusters
def flag_cutpaste_candidates(insertion_from_signature_clusters, deletion_signature_clusters, options):
"""Flag duplication signature clusters if they overlap a deletion"""
int_duplication_candidates = []
for ins_cluster in insertion_from_signature_clusters:
# Compute distances of every deletion cluster to the current insertion/duplication
distances = [(del_index, span_position_distance_clusters(del_cluster, ins_cluster, options.position_distance_normalizer)) \
for del_index, del_cluster in enumerate(deletion_signature_clusters)]
closest_deletion_index, closest_deletion = sorted(distances, key=lambda obj: obj[1])[0]
source_contig, source_start, source_end = ins_cluster.get_source()
dest_contig, dest_start, dest_end = ins_cluster.get_destination()
# If close deletion cluster found
if closest_deletion <= options.del_ins_dup_max_distance:
#Potential cut&paste insertion
int_duplication_candidates.append(CandidateDuplicationInterspersed(source_contig, source_start, source_end, dest_contig, dest_start, dest_end, ins_cluster.members, ins_cluster.score, ins_cluster.std_span, ins_cluster.std_pos, cutpaste=True))
else:
#Interspersed duplication
int_duplication_candidates.append(CandidateDuplicationInterspersed(source_contig, source_start, source_end, dest_contig, dest_start, dest_end, ins_cluster.members, ins_cluster.score, ins_cluster.std_span, ins_cluster.std_pos, cutpaste=False))
return int_duplication_candidates
def get_closest_index(input_list, input_number):
"""
Assumes input_list is sorted. Returns index of closest value to input_number.
If two numbers are equally close, return the index of the smallest number.
"""
if len(input_list) < 1:
return None
pos = bisect_left(input_list, input_number)
if pos == 0:
return 0
if pos == len(input_list):
return len(input_list) - 1
before = input_list[pos - 1]
after = input_list[pos]
if after - input_number < input_number - before:
return pos
else:
return pos - 1
def distance_positions(position1, position2):
return float("inf") if position1[0] != position2[0] else abs(position1[1] - position2[1])
def calculate_score_insertion(main_score, translocation_distances, translocation_stds, destination_stds):
"""Calculate the score of a merged insertion or duplication detected from an insertion.
Parameters: - main_score - score of the underlying main insertion
- translocation_distances - mean distance of the translocation clusters flanking the main insertion (left)
- translocation_stds - standard deviation of the translocation clusters flanking the main insertion (left)
- destination_stds - standard deviations of the left and right translocation destinations"""
#scale translocation distance to [0, 1] range
td0 = max(0, 100 - translocation_distances[0]) / 100
td1 = max(0, 100 - translocation_distances[1]) / 100
#scale translocation std to [0, 1] range
if translocation_stds[0] == None:
ts0 = 1
else:
ts0 = max(0, 100 - translocation_stds[0]) / 100
if translocation_stds[1] == None:
ts1 = 1
else:
ts1 = max(0, 100 - translocation_stds[1]) / 100
#scale destination stds to [0, 1] range
if destination_stds[0] == None:
ds0 = 1
else:
ds0 = max(0, 100 - destination_stds[0]) / 100
if destination_stds[1] == None:
ds1 = 1
else:
ds1 = max(0, 100 - destination_stds[1]) / 100
#calculate final score as product of components
product = td0 * td1 * ts0 * ts1 * ds0 * ds1
final_score = pow(product, 1/6) * main_score
return final_score
def merge_translocations_at_insertions(translocation_signature_clusters, insertion_signature_clusters, options):
if len(insertion_signature_clusters) == 0:
return [], []
#add reverse translocation signature clusters
reversed_translocation_signature_clusters = []
for cluster in translocation_signature_clusters:
reversed_cluster = SignatureClusterBiLocal(cluster.dest_contig, cluster.dest_start, cluster.dest_end,
cluster.source_contig, cluster.source_start, cluster.source_end,
cluster.score, cluster.size, cluster.members, cluster.type, cluster.std_pos, cluster.std_span)
reversed_cluster.direction1 = 'fwd' if cluster.direction2 == 'rev' else 'rev'
reversed_cluster.direction2 = 'fwd' if cluster.direction1 == 'rev' else 'rev'
reversed_translocation_signature_clusters.append(reversed_cluster)
translocation_signature_clusters.extend(reversed_translocation_signature_clusters)
translocation_partitions_fwdfwd_dict = defaultdict(list)
translocation_partitions_revrev_dict = defaultdict(list)
for cluster in translocation_signature_clusters:
if cluster.direction1 == 'fwd' and cluster.direction2 == 'fwd':
translocation_partitions_fwdfwd_dict[cluster.source_contig].append(cluster)
elif cluster.direction1 == 'rev' and cluster.direction2 == 'rev':
translocation_partitions_revrev_dict[cluster.source_contig].append(cluster)
for contig in translocation_partitions_fwdfwd_dict.keys():
translocation_partitions_fwdfwd_dict[contig] = sorted(translocation_partitions_fwdfwd_dict[contig], key=lambda cluster: cluster.get_key())
for contig in translocation_partitions_revrev_dict.keys():
translocation_partitions_revrev_dict[contig] = sorted(translocation_partitions_revrev_dict[contig], key=lambda cluster: cluster.get_key())
translocation_partition_means_fwdfwd_dict = {}
translocation_partition_stds_fwdfwd_dict = {}
for contig in translocation_partitions_fwdfwd_dict.keys():
translocation_partition_means_fwdfwd_dict[contig] = [cluster.source_start for cluster in translocation_partitions_fwdfwd_dict[contig]]
translocation_partition_stds_fwdfwd_dict[contig] = [cluster.std_span for cluster in translocation_partitions_fwdfwd_dict[contig]]
translocation_partition_means_revrev_dict = {}
translocation_partition_stds_revrev_dict = {}
for contig in translocation_partitions_revrev_dict.keys():
translocation_partition_means_revrev_dict[contig] = [cluster.source_start for cluster in translocation_partitions_revrev_dict[contig]]
translocation_partition_stds_revrev_dict[contig] = [cluster.std_span for cluster in translocation_partitions_revrev_dict[contig]]
inserted_regions_to_remove = []
insertion_from_signature_clusters = []
for insertion_index, ins_cluster in enumerate(insertion_signature_clusters):
ins_contig, ins_start, ins_end = ins_cluster.get_source()
try:
closest_to_start_fwdfwd_index = get_closest_index(translocation_partition_means_fwdfwd_dict[ins_contig], ins_start)
closest_to_start_fwdfwd_mean = translocation_partition_means_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index]
closest_to_start_revrev_index = get_closest_index(translocation_partition_means_revrev_dict[ins_contig], ins_start)
closest_to_start_revrev_mean = translocation_partition_means_revrev_dict[ins_contig][closest_to_start_revrev_index]
except KeyError:
continue
# if translocations found close to start of insertion
if abs(closest_to_start_fwdfwd_mean - ins_start) <= options.trans_sv_max_distance and abs(closest_to_start_revrev_mean - ins_start) <= options.trans_sv_max_distance:
destination_from_start_fwdfwd = (translocation_partitions_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index].dest_contig, translocation_partitions_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index].dest_start)
destination_from_start_revrev = (translocation_partitions_revrev_dict[ins_contig][closest_to_start_revrev_index].dest_contig, translocation_partitions_revrev_dict[ins_contig][closest_to_start_revrev_index].dest_start)
destination_from_start_fwdfwd_std = translocation_partitions_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index].std_pos
destination_from_start_revrev_std = translocation_partitions_revrev_dict[ins_contig][closest_to_start_revrev_index].std_pos
# if the two destinations have the right distance
distance = abs(destination_from_start_revrev[1] - destination_from_start_fwdfwd[1])
if destination_from_start_revrev[0] == destination_from_start_fwdfwd[0] and 0.95 <= ((ins_end - ins_start + 1) / (distance + 1)) <= 1.1:
members = ins_cluster.members + translocation_partitions_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index].members + translocation_partitions_revrev_dict[ins_contig][closest_to_start_revrev_index].members
score = calculate_score_insertion(ins_cluster.score,
[abs(closest_to_start_fwdfwd_mean - ins_start), abs(closest_to_start_revrev_mean - ins_start)],
[translocation_partition_stds_fwdfwd_dict[ins_contig][closest_to_start_fwdfwd_index], translocation_partition_stds_revrev_dict[ins_contig][closest_to_start_revrev_index]],
[destination_from_start_fwdfwd_std, destination_from_start_revrev_std])
insertion_from_signature_clusters.append(SignatureClusterBiLocal(destination_from_start_revrev[0], min(destination_from_start_revrev[1], destination_from_start_fwdfwd[1]), max(destination_from_start_revrev[1], destination_from_start_fwdfwd[1]), ins_contig, ins_start, ins_start + distance, score, len(members), members, "DUP_INT", ins_cluster.std_span, ins_cluster.std_pos))
inserted_regions_to_remove.append(insertion_index)
return insertion_from_signature_clusters, inserted_regions_to_remove
svim-2.0.0/src/svim/SVIM_plot.py 0000664 0000000 0000000 00000014541 14063053413 0016426 0 ustar 00root root 0000000 0000000 import matplotlib
import logging
import random
import math
matplotlib.use('Agg')
import matplotlib.pyplot as plt
def plot_sv_lengths(deletion_candidates, inversion_candidates, int_duplication_candidates, tan_dup_candidates, novel_insertion_candidates, options):
len_dict_5 = dict()
len_dict_10 = dict()
len_dict_5["DEL"] = [v.get_source()[2] - v.get_source()[1] for v in deletion_candidates if v.score >= 5]
len_dict_5["INV"] = [v.get_source()[2] - v.get_source()[1] for v in inversion_candidates if v.score >= 5]
len_dict_5["DUP_INT"] = [v.get_destination()[2] - v.get_destination()[1] for v in int_duplication_candidates if v.score >= 5]
len_dict_5["DUP_TAN"] = [v.get_destination()[2] - v.get_destination()[1] for v in tan_dup_candidates if v.score >= 5]
len_dict_5["INS"] = [v.get_destination()[2] - v.get_destination()[1] for v in novel_insertion_candidates if v.score >= 5]
draw_sv_length_plot(dict_of_lengths=len_dict_5, output=options.working_dir + "/sv-lengths-q5.png")
len_dict_10["DEL"] = [v.get_source()[2] - v.get_source()[1] for v in deletion_candidates if v.score >= 10]
len_dict_10["INV"] = [v.get_source()[2] - v.get_source()[1] for v in inversion_candidates if v.score >= 10]
len_dict_10["DUP_INT"] = [v.get_destination()[2] - v.get_destination()[1] for v in int_duplication_candidates if v.score >= 10]
len_dict_10["DUP_TAN"] = [v.get_destination()[2] - v.get_destination()[1] for v in tan_dup_candidates if v.score >= 10]
len_dict_10["INS"] = [v.get_destination()[2] - v.get_destination()[1] for v in novel_insertion_candidates if v.score >= 10]
draw_sv_length_plot(dict_of_lengths=len_dict_10, output=options.working_dir + "/sv-lengths-q10.png")
def draw_sv_length_plot(dict_of_lengths, output):
"""Makes two stacked bar charts
Plotting two bar charts of number of SVs by length split by SV type
Use a consistent colouring scheme for those in "standard_order" to
make comparison reasonable
First bar chart is up to 2kb with bins of 10bp
Second bar chart is up to 20kb, with bins of 100bp
and uses log scaling on the y-axis
"""
standard_order = ['DEL', 'INS', 'INV', 'DUP_INT', 'DUP_TAN']
names, lengths = zip(
*sorted([(svtype, lengths) for svtype, lengths in dict_of_lengths.items()],
key=lambda x: standard_order.index(x[0])))
plt.subplot(2, 1, 1)
plt.hist(x=lengths,
bins=[i for i in range(0, 2000, 10)],
stacked=True,
histtype='bar',
label=names)
plt.xlabel('Length of structural variant')
plt.ylabel('Number of variants')
plt.legend(frameon=False,
fontsize="small")
plt.subplot(2, 1, 2)
plt.hist(x=lengths,
bins=[i for i in range(0, 20000, 100)],
stacked=True,
histtype='bar',
label=names,
log=True)
plt.xlabel('Length of structural variant')
plt.ylabel('Number of variants')
plt.legend(frameon=False,
fontsize="small")
plt.tight_layout()
plt.savefig(output)
plt.clf()
def plot_sv_alleles(candidates, options):
refs_11 = [candidate.ref_reads for candidate in candidates if candidate.genotype == '1/1' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
alts_11 = [candidate.alt_reads for candidate in candidates if candidate.genotype == '1/1' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
refs_10 = [candidate.ref_reads for candidate in candidates if candidate.genotype == '0/1' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
alts_10 = [candidate.alt_reads for candidate in candidates if candidate.genotype == '0/1' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
refs_00 = [candidate.ref_reads for candidate in candidates if candidate.genotype == '0/0' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
alts_00 = [candidate.alt_reads for candidate in candidates if candidate.genotype == '0/0' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
refs_nn = [candidate.ref_reads for candidate in candidates if candidate.genotype == './.' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
alts_nn = [candidate.alt_reads for candidate in candidates if candidate.genotype == './.' and candidate.score >= 5 and candidate.ref_reads != None and candidate.alt_reads != None]
draw_allele_plot(refs_11, alts_11, refs_10, alts_10, refs_00, alts_00, refs_nn, alts_nn, output=options.working_dir + "/sv-genotypes-q5.png")
def draw_allele_plot(refs_11, alts_11, refs_10, alts_10, refs_00, alts_00, refs_nn, alts_nn, output):
"""Makes a scatter plot of allele support
"""
num_points = len(refs_11)+len(refs_10)+len(refs_00)+len(refs_nn)
point_alpha = 10 / math.sqrt(max(100, num_points))
plt.scatter(x=[ref+random.uniform(-0.5, 0.5) for ref in refs_11],
y=[alt+random.uniform(-0.5, 0.5) for alt in alts_11],
c='tab:red',
alpha=point_alpha,
label='1/1',
edgecolors='none')
plt.scatter(x=[ref+random.uniform(-0.5, 0.5) for ref in refs_10],
y=[alt+random.uniform(-0.5, 0.5) for alt in alts_10],
c='tab:purple',
alpha=point_alpha,
label='0/1',
edgecolors='none')
plt.scatter(x=[ref+random.uniform(-0.5, 0.5) for ref in refs_00],
y=[alt+random.uniform(-0.5, 0.5) for alt in alts_00],
c='tab:blue',
alpha=point_alpha,
label='0/0',
edgecolors='none')
plt.scatter(x=[ref+random.uniform(-0.5, 0.5) for ref in refs_nn],
y=[alt+random.uniform(-0.5, 0.5) for alt in alts_nn],
c='tab:brown',
alpha=point_alpha,
label='./.',
edgecolors='none')
axes = plt.gca()
axes.set_xlim([0,60])
axes.set_ylim([0,60])
plt.xlabel('Reference allele support')
plt.ylabel('Variant allele support')
leg = plt.legend(frameon=True,
fontsize="medium")
for lh in leg.legendHandles:
lh.set_alpha(1.0)
plt.tight_layout()
plt.savefig(output)
plt.clf() svim-2.0.0/src/svim/SVSignature.py 0000664 0000000 0000000 00000031657 14063053413 0017033 0 ustar 00root root 0000000 0000000 import logging
class Signature:
"""Signature class for basic signatures of structural variants. An signature is always detected from a single read.
"""
def __init__(self, contig, start, end, signature, read):
self.contig = contig
self.start = start
self.end = end
self.signature = signature
self.read = read
self.type = None
if self.end < self.start:
logging.warning("Signature with invalid coordinates (end < start): " + self.as_string())
def get_source(self):
return (self.contig, self.start, self.end)
def get_key(self):
contig, start, end = self.get_source()
return (self.type, contig, end)
def downstream_distance_to(self, signature2):
"""Return distance >= 0 between this signature's end and the start of signature2."""
this_contig, this_start, this_end = self.get_source()
other_contig, other_start, other_end = signature2.get_source()
if self.type == signature2.type and this_contig == other_contig:
return max(0, other_start - this_end)
else:
return float("inf")
def as_string(self, sep="\t"):
contig, start, end = self.get_source()
return sep.join(["{0}","{1}","{2}","{3}","{4}"]).format(contig, start, end, "{0};{1}".format(self.type, self.signature), self.read)
class SignatureDeletion(Signature):
"""SV Signature: a region (contig:start-end) has been deleted and is not present in sample"""
def __init__(self, contig, start, end, signature, read):
self.contig = contig
assert end >= start
#0-based start of the deletion (first deleted base)
self.start = start
#0-based end of the deletion (one past the last deleted base)
self.end = end
self.signature = signature
self.read = read
self.type = "DEL"
class SignatureInsertion(Signature):
"""SV Signature: a region of length end-start has been inserted at contig:start"""
def __init__(self, contig, start, end, signature, read, sequence):
self.contig = contig
assert end >= start
#0-based start of the insertion (base after the insertion)
self.start = start
#0-based start of the insertion (base after the insertion) + length of the insertion
self.end = end
self.signature = signature
self.read = read
self.sequence = sequence
self.type = "INS"
def get_key(self):
contig, start, end = self.get_source()
return (self.type, contig, start)
def downstream_distance_to(self, signature2):
"""Return distance >= 0 between this signature's end and the start of signature2."""
this_contig, this_start, this_end = self.get_source()
other_contig, other_start, other_end = signature2.get_source()
if self.type == signature2.type and this_contig == other_contig:
return max(0, other_start - this_start)
else:
return float("inf")
class SignatureInversion(Signature):
"""SV Signature: a region (contig:start-end) has been inverted in the sample"""
def __init__(self, contig, start, end, signature, read, direction):
self.contig = contig
assert end >= start
#0-based start of the inversion (first inverted base)
self.start = start
#0-based end of the inversion (one past the last inverted base)
self.end = end
self.signature = signature
self.read = read
self.type = "INV"
self.direction = direction
def as_string(self, sep="\t"):
contig, start, end = self.get_source()
return sep.join(["{0}","{1}","{2}","{3}","{4}"]).format(contig, start, end, "{0};{1};{2}".format(self.type, self.direction, self.signature), self.read)
class SignatureInsertionFrom(Signature):
"""SV Signature: a region (contig:start-end) has been inserted at contig2:pos in the sample"""
def __init__(self, contig1, start, end, contig2, pos, signature, read):
self.contig1 = contig1
assert end >= start
#0-based start of the region (first copied base)
self.start = start
#0-based end of the region (one past the last copied base)
self.end = end
self.contig2 = contig2
#0-based start of the insertion (base after the insertion)
self.pos = pos
self.signature = signature
self.read = read
self.type = "DUP_INT"
def get_source(self):
return (self.contig1, self.start, self.end)
def get_destination(self):
source_contig, source_start, source_end = self.get_source()
return (self.contig2, self.pos, self.pos + (source_end - source_start))
def get_key(self):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
return (self.type, dest_contig, source_contig, dest_start)
def downstream_distance_to(self, signature2):
"""Return distance >= 0 between this signature's end and the start of signature2."""
this_source_contig, this_source_start, this_source_end = self.get_source()
other_source_contig, other_source_start, other_source_end = signature2.get_source()
this_destination_contig, this_destination_start, this_destination_end = self.get_destination()
other_destination_contig, other_destination_start, other_destination_end = signature2.get_destination()
if self.type == signature2.type and \
this_destination_contig == other_destination_contig and \
this_source_contig == other_source_contig:
return max(0, other_destination_start - this_destination_start)
else:
return float("inf")
def as_string(self, sep="\t"):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
return sep.join(["{0}:{1}-{2}","{3}:{4}-{5}","{6}", "{7}"]).format(source_contig, source_start, source_end,
dest_contig, dest_start, dest_end,
"{0};{1}".format(self.type, self.signature), self.read)
class SignatureDuplicationTandem(Signature):
"""SV Signature: a region (contig:start-end) has been tandemly duplicated"""
def __init__(self, contig, start, end, copies, fully_covered, signature, read):
self.contig = contig
assert end >= start
#0-based start of the region (first copied base)
self.start = start
#0-based end of the region (one past the last copied base)
self.end = end
#number of copies inserted after end of the region (in tandem)
self.copies = copies
self.fully_covered = fully_covered
self.signature = signature
self.read = read
self.type = "DUP_TAN"
def get_destination(self):
source_contig, source_start, source_end = self.get_source()
return (source_contig, source_end, source_end + self.copies * (source_end - source_start))
def as_string(self, sep="\t"):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
return sep.join(["{0}:{1}-{2}","{3}:{4}-{5}","{6}", "{7}"]).format(source_contig, source_start, source_end,
dest_contig, dest_start, dest_end,
"{0};{1};{2}".format(self.type, self.signature, self.copies), self.read)
class SignatureTranslocation(Signature):
"""SV Signature: two positions (contig1:pos1 and contig2:pos2) are connected in the sample"""
def __init__(self, contig1, pos1, direction1, contig2, pos2, direction2, signature, read):
if contig1 < contig2 or (contig1 == contig2 and pos1 < pos2):
self.contig1 = contig1
#0-based source of the translocation (first base before the translocation)
self.pos1 = pos1
self.direction1 = direction1
self.contig2 = contig2
#0-based destination of the translocation (first base after the translocation)
self.pos2 = pos2
self.direction2 = direction2
else:
self.contig1 = contig2
#0-based source of the translocation (first base before the translocation)
self.pos1 = pos2
self.direction1 = 'fwd' if direction2 == 'rev' else 'rev'
self.contig2 = contig1
#0-based destination of the translocation (first base after the translocation)
self.pos2 = pos1
self.direction2 = 'fwd' if direction1 == 'rev' else 'rev'
self.signature = signature
self.read = read
self.type = "BND"
def get_source(self):
return (self.contig1, self.pos1, self.pos1 + 1)
def get_destination(self):
return (self.contig2, self.pos2, self.pos2 + 1)
def as_string(self, sep="\t"):
source_contig, source_start, source_end = self.get_source()
dest_contig, dest_start, dest_end = self.get_destination()
return sep.join(["{0}:{1}-{2}","{3}:{4}-{5}","{6}", "{7}"]).format(source_contig, source_start, source_end,
dest_contig, dest_start, dest_end,
"{0};{1}".format(self.type, self.signature), self.read)
def get_key(self):
return (self.type, self.contig1, self.pos1)
class SignatureClusterUniLocal(Signature):
"""Signature cluster class for clusters of signatures with only one genomic location.
"""
def __init__(self, contig, start, end, score, size, members, type, std_span, std_pos):
self.contig = contig
self.start = start
self.end = end
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.size = size
self.members = members
self.type = type
def get_bed_entry(self):
return "{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format(self.contig, self.start, self.end, "{0};{1};{2};{3}".format(self.type, self.size, self.std_span, self.std_pos), self.score, "["+"][".join([ev.as_string("|") for ev in self.members])+"]")
def get_vcf_entry(self):
if self.type in ["DEL", "INS", "INV"]:
return "{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}".format(self.contig, self.start+1, ".", "N", "<" + self.type + ">", ".", "PASS", "SVTYPE={0};END={1};SVLEN={2};STD_SPAN={3};STD_POS={4}".format(self.type, self.end, self.end - self.start, self.std_span, self.std_pos))
else:
return
def get_length(self):
return self.end - self.start
class SignatureClusterBiLocal(Signature):
"""Signature cluster class for clusters of signatures with two genomic locations (source and destination).
"""
def __init__(self, source_contig, source_start, source_end, dest_contig, dest_start, dest_end, score, size, members, type, std_span, std_pos):
self.source_contig = source_contig
self.source_start = source_start
self.source_end = source_end
self.dest_contig = dest_contig
self.dest_start = dest_start
self.dest_end = dest_end
self.score = score
self.std_span = std_span
self.std_pos = std_pos
self.size = size
self.members = members
self.type = type
def get_source(self):
return (self.source_contig, self.source_start, self.source_end)
def get_destination(self):
return (self.dest_contig, self.dest_start, self.dest_end)
def get_bed_entries(self):
source_entry = "{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format(self.source_contig, self.source_start, self.source_end, "{0}_source;{1}:{2}-{3};{4};{5};{6}".format(self.type, self.dest_contig, self.dest_start, self.dest_end, self.size, self.std_span, self.std_pos), self.score, "["+"][".join([ev.as_string("|") for ev in self.members])+"]")
dest_entry = "{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format(self.dest_contig, self.dest_start, self.dest_end, "{0}_dest;{1}:{2}-{3};{4}".format(self.type, self.source_contig, self.source_start, self.source_end, self.size), self.score, "["+"][".join([ev.as_string("|") for ev in self.members])+"]")
return (source_entry, dest_entry)
def get_vcf_entry(self):
if self.type == "DUP_TAN":
return "{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}".format(self.source_contig, self.source_start+1, ".", "N", "", ".", "PASS", "SVTYPE={0};END={1};SVLEN={2};STD_SPAN={3};STD_POS={4}".format("DUP:TANDEM", self.source_end, self.source_end - self.source_start, self.std_span, self.std_pos))
else:
return
def get_source_length(self):
return self.source_end - self.source_start
def get_destination_length(self):
return self.dest_end - self.dest_start svim-2.0.0/src/svim/__init__.py 0000664 0000000 0000000 00000000000 14063053413 0016332 0 ustar 00root root 0000000 0000000 svim-2.0.0/src/svim/svim 0000664 0000000 0000000 00000027623 14063053413 0015146 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
__version__ = '2.0.0'
__author__ = 'David Heller'
import sys
import os
import re
import pickle
import gzip
import logging
import pysam
from time import strftime, localtime
from svim.SVIM_input_parsing import parse_arguments, guess_file_type, read_file_list
from svim.SVIM_alignment import run_alignment
from svim.SVIM_COLLECT import analyze_alignment_file_coordsorted, analyze_alignment_file_querysorted
from svim.SVIM_CLUSTER import cluster_sv_signatures, write_signature_clusters_bed, write_signature_clusters_vcf
from svim.SVIM_COMBINE import combine_clusters, write_candidates, write_final_vcf
from svim.SVIM_genotyping import genotype
from svim.SVIM_plot import plot_sv_lengths, plot_sv_alleles
def main():
# Fetch command-line options
options = parse_arguments(program_version=__version__)
if not options.sub:
print("Please choose one of the two modes ('reads' or 'alignment'). See --help for more information.")
return
# Set up logging
logFormatter = logging.Formatter("%(asctime)s [%(levelname)-7.7s] %(message)s")
rootLogger = logging.getLogger()
if options.verbose:
rootLogger.setLevel(logging.DEBUG)
else:
rootLogger.setLevel(logging.INFO)
# Create working dir if it does not exist
if not os.path.exists(options.working_dir):
os.makedirs(options.working_dir)
# Create log file
fileHandler = logging.FileHandler("{0}/SVIM_{1}.log".format(options.working_dir, strftime("%y%m%d_%H%M%S", localtime())), mode="w")
fileHandler.setFormatter(logFormatter)
rootLogger.addHandler(fileHandler)
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(logFormatter)
rootLogger.addHandler(consoleHandler)
logging.info("****************** Start SVIM, version {0} ******************".format(__version__))
logging.info("CMD: python3 {0}".format(" ".join(sys.argv)))
logging.info("WORKING DIR: {0}".format(os.path.abspath(options.working_dir)))
for arg in vars(options):
logging.info("PARAMETER: {0}, VALUE: {1}".format(arg, getattr(options, arg)))
logging.info("****************** STEP 1: COLLECT ******************")
if options.sub == 'reads':
logging.info("MODE: reads")
logging.info("INPUT: {0}".format(os.path.abspath(options.reads)))
logging.info("GENOME: {0}".format(os.path.abspath(options.genome)))
reads_type = guess_file_type(options.reads)
if reads_type == "unknown":
return
elif reads_type == "list":
# List of read files
sv_signatures = []
#Translocation signatures from other SV classes are stored separately for --all_bnd option
translocation_signatures_all_bnds = []
for index, file_path in enumerate(read_file_list(options.reads)):
logging.info("Starting processing of file {0} from the list..".format(index))
reads_type = guess_file_type(file_path)
if reads_type == "unknown" or reads_type == "list":
return
bam_path = run_alignment(options.working_dir, options.genome, file_path, reads_type, options.cores, options.aligner, options.nanopore)
aln_file = pysam.AlignmentFile(bam_path)
sigs, trans_sigs = analyze_alignment_file_coordsorted(aln_file, options)
sv_signatures.extend(sigs)
translocation_signatures_all_bnds.extend(trans_sigs)
else:
# Single read file
bam_path = run_alignment(options.working_dir, options.genome, options.reads, reads_type, options.cores, options.aligner, options.nanopore)
aln_file = pysam.AlignmentFile(bam_path)
sv_signatures, translocation_signatures_all_bnds = analyze_alignment_file_coordsorted(aln_file, options)
elif options.sub == 'alignment':
logging.info("MODE: alignment")
logging.info("INPUT: {0}".format(os.path.abspath(options.bam_file)))
aln_file = pysam.AlignmentFile(options.bam_file)
try:
if aln_file.header["HD"]["SO"] == "coordinate":
try:
aln_file.check_index()
except ValueError:
logging.warning("Input BAM file is missing a valid index. Please generate with 'samtools index'. Continuing without genotyping for now..")
options.skip_genotyping = True
except AttributeError:
logging.warning("pysam's .check_index raised an Attribute error. Something is wrong with the input BAM file.")
return
sv_signatures, translocation_signatures_all_bnds = analyze_alignment_file_coordsorted(aln_file, options)
elif aln_file.header["HD"]["SO"] == "queryname":
sv_signatures, translocation_signatures_all_bnds = analyze_alignment_file_querysorted(aln_file, options)
logging.warning("Skipping genotyping because it requires a coordinate-sorted input BAM file and an index. The given file, however, is queryname-sorted according to its header line.")
options.skip_genotyping = True
else:
logging.error("Input BAM file needs to be coordinate-sorted or queryname-sorted. The given file, however, is unsorted according to its header line.")
return
except KeyError:
logging.error("Is the given input BAM file sorted? It does not contain a sorting order in its header line.")
return
deletion_signatures = [ev for ev in sv_signatures if ev.type == "DEL"]
insertion_signatures = [ev for ev in sv_signatures if ev.type == "INS"]
inversion_signatures = [ev for ev in sv_signatures if ev.type == "INV"]
tandem_duplication_signatures = [ev for ev in sv_signatures if ev.type == "DUP_TAN"]
translocation_signatures = [ev for ev in sv_signatures if ev.type == "BND"]
insertion_from_signatures = [ev for ev in sv_signatures if ev.type == "DUP_INT"]
logging.info("Found {0} signatures for deleted regions.".format(len(deletion_signatures)))
logging.info("Found {0} signatures for inserted regions.".format(len(insertion_signatures)))
logging.info("Found {0} signatures for inverted regions.".format(len(inversion_signatures)))
logging.info("Found {0} signatures for tandem duplicated regions.".format(len(tandem_duplication_signatures)))
logging.info("Found {0} signatures for translocation breakpoints.".format(len(translocation_signatures)))
if options.all_bnds:
logging.info("Found {0} signatures for translocation breakpoints from other SV classes (DEL, INV, DUP).".format(len(translocation_signatures_all_bnds)))
logging.info("Found {0} signatures for inserted regions with detected region of origin.".format(len(insertion_from_signatures)))
logging.info("****************** STEP 2: CLUSTER ******************")
signature_clusters = cluster_sv_signatures(sv_signatures, options)
if options.all_bnds:
rootLogger.setLevel(logging.WARNING)
translocation_signature_clusters_all_bnds = cluster_sv_signatures(translocation_signatures_all_bnds, options)
if options.verbose:
rootLogger.setLevel(logging.DEBUG)
else:
rootLogger.setLevel(logging.INFO)
# Write SV signature clusters
logging.info("Finished clustering. Writing signature clusters..")
if options.all_bnds:
all_signature_clusters = (signature_clusters[0], signature_clusters[1], signature_clusters[2], signature_clusters[3], signature_clusters[4], signature_clusters[5] + translocation_signature_clusters_all_bnds[5])
write_signature_clusters_bed(options.working_dir, all_signature_clusters)
write_signature_clusters_vcf(options.working_dir, all_signature_clusters, __version__)
else:
write_signature_clusters_bed(options.working_dir, signature_clusters)
write_signature_clusters_vcf(options.working_dir, signature_clusters, __version__)
logging.info("****************** STEP 3: COMBINE ******************")
deletion_candidates, inversion_candidates, int_duplication_candidates, tan_dup_candidates, novel_insertion_candidates, breakend_candidates = combine_clusters(signature_clusters, options)
if options.all_bnds:
rootLogger.setLevel(logging.WARNING)
breakend_candidates_all_bnds = combine_clusters(translocation_signature_clusters_all_bnds, options)[5]
if options.verbose:
rootLogger.setLevel(logging.DEBUG)
else:
rootLogger.setLevel(logging.INFO)
if not options.skip_genotyping:
logging.info("****************** STEP 4: GENOTYPE ******************")
logging.info("Genotyping deletions..")
genotype(deletion_candidates, aln_file, "DEL", options)
logging.info("Genotyping inversions..")
genotype(inversion_candidates, aln_file, "INV", options)
logging.info("Genotyping novel insertions..")
genotype(novel_insertion_candidates, aln_file, "INS", options)
logging.info("Genotyping interspersed duplications..")
genotype(int_duplication_candidates, aln_file, "DUP_INT", options)
# Write SV candidates
logging.info("Write SV candidates..")
logging.info("Final deletion candidates: {0}".format(len(deletion_candidates)))
logging.info("Final inversion candidates: {0}".format(len(inversion_candidates)))
logging.info("Final interspersed duplication candidates: {0}".format(len(int_duplication_candidates)))
logging.info("Final tandem duplication candidates: {0}".format(len(tan_dup_candidates)))
logging.info("Final novel insertion candidates: {0}".format(len(novel_insertion_candidates)))
logging.info("Final breakend candidates: {0}".format(len(breakend_candidates)))
types_to_output = [entry.strip() for entry in options.types.split(",")]
if options.all_bnds:
logging.info("Final breakend candidates from other SV classes (DEL, INV, DUP): {0}".format(len(breakend_candidates_all_bnds)))
write_candidates(options.working_dir, (int_duplication_candidates, inversion_candidates, tan_dup_candidates, deletion_candidates, novel_insertion_candidates, breakend_candidates + breakend_candidates_all_bnds))
write_final_vcf(int_duplication_candidates,
inversion_candidates,
tan_dup_candidates,
deletion_candidates,
novel_insertion_candidates,
breakend_candidates + breakend_candidates_all_bnds,
__version__,
aln_file.references,
aln_file.lengths,
types_to_output,
options)
else:
write_candidates(options.working_dir, (int_duplication_candidates, inversion_candidates, tan_dup_candidates, deletion_candidates, novel_insertion_candidates, breakend_candidates))
write_final_vcf(int_duplication_candidates,
inversion_candidates,
tan_dup_candidates,
deletion_candidates,
novel_insertion_candidates,
breakend_candidates,
__version__,
aln_file.references,
aln_file.lengths,
types_to_output,
options)
logging.info("Draw plots..")
rootLogger.setLevel(logging.WARNING)
plot_sv_lengths(deletion_candidates, inversion_candidates, int_duplication_candidates, tan_dup_candidates, novel_insertion_candidates, options)
if not options.skip_genotyping:
plot_sv_alleles(deletion_candidates + inversion_candidates + int_duplication_candidates + novel_insertion_candidates, options)
if options.verbose:
rootLogger.setLevel(logging.DEBUG)
else:
rootLogger.setLevel(logging.INFO)
logging.info("Done.")
if __name__ == "__main__":
try:
sys.exit(main())
except Exception as e:
logging.error(e, exc_info=True)
svim-2.0.0/src/tests/ 0000775 0000000 0000000 00000000000 14063053413 0014417 5 ustar 00root root 0000000 0000000 svim-2.0.0/src/tests/__init__.py 0000664 0000000 0000000 00000000000 14063053413 0016516 0 ustar 00root root 0000000 0000000 svim-2.0.0/src/tests/chimeric_read.sam 0000664 0000000 0000000 00000142025 14063053413 0017703 0 ustar 00root root 0000000 0000000 @HD VN:1.0 SO:queryname
@SQ SN:chr21 LN:48129895
read1 0 chr21 35346115 60 33M1I35M1D13M1D4M1I16M1D15M1I14M1I12M1D3M1D39M1D25M1I33M1I10M1I9M1I78M1I66M1I9M1D7M1I37M2I28M1I12M1I6M1I34M1I6M1I17M2I21M1I20M1I29M1I5M1I5M1I12M2I52M1I5M1I7M1I8M1I63M1D8M1I12M1I4M1I59M1D11M1I9M1I8M1D4M2I7M1D16M1D55M1D10M1I4M1I17M1I53M1I17M1I124M1I96M1I3M1I14M1I5M1I2M1I8M2I3M1I2M1I23M1I21M1I123M1I3M1I5M1D7M1I7M1I59M1I84M1I39M1I20M1I28M1I15M1I4M1I12M1I26M1D44M1I3M1I47M1I37M1I3M1D64M1I5M1D65M1I29M1I59M1I3M1I34M1D18M1D15M1D17M1I5M1I52M1D3M1I22M1I56M1I5M1I12M1D23M1I15M1I5M1I53M2I19M1D20M1I15M1I4M1D24M1I12M1I21M1I95M2I30M1I4M1D21M1I6M1I23M1I12M1I41M1I7M1I20M2I11M1D19M1I8M1I16M1D18M2I7M1D19M1I13M1I19M1I7M1I33M1I35M1I10M1I8M1I3M1I16M2I8M1I13M1I29M1I11M1I14M1I17M1I37M1I24M1D38M1I7M1I6M2I95M1D52M1I14M1I16M1I19M1I1M1D35M1I2M1D23M1I1M1I12M1I17M1I3M1I77M1I18M1I3M1I2M1I2M1I9M1I9M1I2M1I10M1I13M1I6M1I2M1I21M1I52M1D2M1I28M1I10M2I28M1I5M1I8M1I15M1I22M1D7M1I19M1I43M1D7M1D9M1I5M1D4M1D12M1I1M1I26M1I4M1I7M1I7M1D21M1I7M1I5M1D5M1I12M1I27M2I32M1I17M1I21M1I13M1D15M1I81M1I19M1D2M1I14M1I8M1I15M1I4M1I38M1I23M1I9M1I12M1I7M1D10M1I6M1I14M1I8M1I28M1I13M1I26M1I35M1I9M1D17M1I8M1I6M1D7M1D6M1I5M1I2M1I38M1I11M1D21M1I25M1D10M2I17M1D15M1I3M1I42M1I17M1D79M1I2M1I17M1I26M1I30M2I52M1I4M1I1M1D16M1I6M1I18M1D19M2I11M1I25M1I19M1D3M1I2M1I16M1I10M1D4M2I15M1I2M1D4M1I37M1I13M2I25M1D32M1D4M1I8M1I13M1I2M1I6M1I1M1D74M1I8M1I14M1I28M1I27M1I37M1D19M1I14M1I5M1I20M1I13M1D4M1D15M1I5M1D27M1D7M1I1M1I23M1I33M1I26M1I44M1D14M1I6M1D12M1I39M1I8M1I5M1I6M1I16M1I15M1I3M1I11M1I22M1D1M1D8M1D110M1I12M1I1M1I4M1I4M1I28M2I15M3405S * 0 0 TCCTTGCCTTTCAGGTGCTTTAAGAGGGCTTATCGTTCTTTGACTCCCCTAGTAACTCAAAAGGGTGGCAAGATGCAACTCTGAGGCTTTCCAAGCTCTCTGCAAGCCTGCCTTCAGTAAGTCTGTGCACCACAAAGAAGCATAACTTATATCCTCTAGCTGAATTTACCTCCTGCTTCGAGCCCCTGTTTCCCATGTCATTTTAGGGGTCCAGATGTTTTTCCTGGAGGCATATACACACACACACTACACACACACAACACACACATCACACACACACACACACACACATATATACACACACACATTCCAGGGGCCTCTGAGGTGCCAAGACATGTGTGGGGTCCAATCTGGTTAACACTGATGTCCATGATCATTGAGTTCATTTTTTATATCAACTATGTGACACTTCCTGATAGTTTCCGTTCCTGTGTTAGAATTTGCAAAGTTGCCGACTATTTCTTTGAATGAAGAGTAGCTAGATCATGGGTCTACACCAGGTCATCAAGCAGCCGATTTCCCCTGTTGGAAGCTCCAAGCAAATTGTCAGCTCCAAGCATTGCCACACAGCTGTGGGTGTGCCACACTCCTTTTCCTTTTAATAAGATGATGATCTGCTAGTGTGTGAATGCTCTTGGAGTTTTATTTGTAGGTTTTTTCCTTGTATGTCGCAAATGTATCTATATTTCATCTTCCCTCTTGAGGGATATTTTCCATGGGTAGAGGATCTAGCGCTTTCTCTTTTGCGATTCCATGTGTGGCTTTAAAAAAAAGTCAGTTGACTGTTTATTTATGGCTTCTCTAAAGGTGATCTCTTTCTCCTAAGGACTGCTTTAAAAGCTTTCGCGTTCCCTCCCTCCCTTCCTCCCACCCCATCCCCCTTCTTCCTTTCCTTCCTCCCTCCCTCCTCCCTTCTGCTTCCTCCCTTTTCTCCCTGTCGTTTCCTCCTTTCTCCCATCCTCCCTCCTCCCTCTTTCCTTCTTTTTTCCCTTCCTCCCGCCCTCCTTCCTTCTTCCATCTTATATATTATAAATAATTTTCTTTCTTTCTTTATTTTTTTTTGAGATGGAGTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAACGGTGGTGATCTTGGCTTACTGCCAACCTCCACCTCCCTGGTTCAAGCGATTCACCTGCCTCAGCCTCCCTAGTAGCTGGGATTACAGGTGCCCGCCACCACACCCAGCTAATTTTTGTAATTGTAGTAGAGATGGGGTTTCACCATGGTGGGCCAGGCTGGTCTTGAACTCCTGAACTCAGGTAATCCACCCGCCTTGTCCTCCCAAAGTGCTGGAATTACAGGCATGAGCCACCACTCCCAGCCCTAATTAAAATATTTTCTTTCTGAGGCCCTTCCCTACCCTCTTGTACTTCTTTTGATACCGCCATCATAATGCATGTTAGGTGGACTCATCTGTGTACTCTATTACCCTCTCATCTGGTTTTTAATCTTTCTGTCTCCTTATACTGTAATCTCAGTGTTTCTTCTGCTTTAATTTTGGTATATGAATTATTCAGCTGTGTTCAAAGTGTGGTTCAAATGCGACTATATGCTTCTTTAAGTTTTTAGTTATTGTACTTCTCACCTCTAGAAGTTCTTCTGTGACACTTCTTATAGTTTCGCAGTTCTTGGGTAGAATTTGCAAACTTGTTGACTATTTCTTTGAAAAGAGTAGCTAGAATTGTTTTAGTCTGTGTATAGTGAGTATGAATATCTGAAACCTCTGTGAGTCTGTTTCTTTTGTCTCGCTAGCCCTACTCATGGCGTCCATGTTTTCCTGGATGTTTAGTTGGTTGTTCTTTGAATATGTCCAAACTCCCAGTTATTTCTGGGGAATACCCAAAGGCACACCTGTTCCTATCACCCAGTGAACTGCCATGTGTTTGTCTCCTGTCATGGTAGACATTTTGCATTCAGGGAGAGGCCTCTGCTCTCTGCAGAACAGTGTGAAATGCACCTCATTTTTGCCTTCAATGAAGGTTGTCTCTTGCTTGGCACCACCACTTCCTCAAATGACTAATGCCACTCTTGCTCACAGTGCTAAGGCGCTAAGGAGTTTATCAGAGGCTAGAGTGATTCTGCATCCTCTGGGGTTCTCAGGAAGCGAGGCCACAGGGCCATCTGTGCATGTAGTGACAGTGGGGTGGGGTGGATGAGCAGTTGGCAGTGGTGGGCACCTATGCTGCTGGCGCCACAGCTTTTTATATCTTGGTGAAAACAGACGCCCTTGCGTTTTCACTTGTAGATTCTCCGGCTACATCCACAAGAACAAATTCTGTCACAGAGGCCAGATAGACTATCAGTGTAATGGGCCCTTTCCCCTTTGATGATAGCAGCTTTTTTCGGGGGAGCAGGGGTTGCCAAACTTCTACGCCTTATTTTATCTTCCTTTCTGAGTTCTCCCCAGAGGCTGCTGGGTCCACCTCTCCCTCTGCCAGACAGACAGGCTCAGGACATAGCAAGAACGGAAGGGGTGTGGGGGTTGGTGGGAGGTATTAAGTTGGGGAAACGACAGCTCTTGTCTTTGTAGATTACCAGAACTGACACACGTACACACACGTACACTCACGCTCACTCACTCACTCATCTATCATCTATTTTTGGCCTAAGCTGCCTTTGGACACTTCCTTCGAAAAGCACATGAACTCTTCGGAGTTCTCCTGTTCCACCTTGGTAAATTTCCTATAGCCAACGCACTGAAAGTCCCTGCTGCCCTCCTTCCTCTGAGCTTGTGGGGCCCACAGATCCCCTGCTCCATTTCCTGCTTCATTTCAGCTGATGGTGAGCTTCCAGGGCAGGCTTGTAGGAAGGGCGGGCTAAGGCTGGGGAACTGCAGCACCCACCACCACCCGCCCGCCCCAGTGCTTGTTGCCCCTAGCCTCTGTCTCTCCTCGCTGTGCCCTTCCCTTAAGCCCCACTCTTGGCCTCCCACAAAGACAAGAGTTTGTTCTGTTTTTATATTGATAGGATGAACTCCCTCGTTCTAATACCTATCTGAATAGCCTGAGCAATTACATTTACAACCTCATGAAAAATACACAGCACTTGTCACGATGAATGATGTTTACCGTGAATAATTGCAGTTTTGAGTTCAAACATCCTTCTATAGTCCAAGAATGAGTAAATATCCCTATTCCCTACCCCTCCCCATTGCATTTGGGTTTGACATGACATGCAATCATTGTGAGTTTTACTGCCTGGGGTAGAATTGTTTTTGCCTGTATTGCCATTGCCAATTGACTGGAAGGACAAAAAAAGGAAACTTACCAATTGAGCAGTTTCTAGATGAACTTAAATATCTCAGAAATCTTGAAGCAATGAATGAACTATAACTTTCTGAAGTTGCAAAAATGATTCAAGTCGGAAGTGACCCATGGGAGCAACCTGGTCCTTAATTAGGACTGGAAAGAAAACGGTAGGCCCATGCGAGGTGGAACAGTGGCTTCCCCAAGGTCACACTGCAAGTGAGTGGTGGCACTAGTCACCCAGGAGTCCTCCTGACTCCATGGTATCCTGACCCCAGACCAGAGCCTTATTTGTGGTTAAAGAACGTGGAAAAACAGCTTATGTTTGAATTTTAGAAATCATGCCAGTAGCTAAAGATCTGCATTCTCATGAATATTGAGCTTTGCGTTGTGCGGGTTGCTACGAATTTTGTAACTATTTTCTCCTAGAGCTCTCAGTATTTTACATATGACCAATTCCATTCTATTATTGTCCCGGGAAAAGAGTGTGCATTTACTGAGCAGTAAGAGGGTGATTTGAAGTCCCTGGGGTCCCCCACCCTTGTCTTTCTATGTGAGATTGTATGTGCAGGGCTCACATTTATGTCTCCTCCAGGCAGCTCATGTGCACAGACTAGTTGTATTTATTAGAGCACCTACTGTGGTGCCATGGAAGCTATGTGGTAAGCTAAGCAGGACAAAAACTCCTGCTCTCACAAGAAGAAAGAATAAACAAGCAGACAATTGCCCGTATAATGTCAGCCTGGTGTGATGGCTCATCTCCTGGAATACCCTAGCACTTTGGGAGGTGACGATGGGAGGGATTGGCTTTAACTTCGGGAGTTCAAGATAAAGCCTGGGCAACCAAGACCCTTCTCTACAAAAAAAATCAAAAAATTAGACTGGGGGTCATGGCATGAGTCTCTGGCCCCTCGGGACCAGAGGCTCGGGAGCTGAGGCGTGGTTTTCACTGAGCCTGGGAGCGTTTGAGGCTGCAGTGAGCTGTGATCACAACCACCTGCACTGCCAGCCTGGCCACAGAGCGAGACCCTGTCCTCTAAATTAAACAACAACCCTAATGTCAAGATTAGGAAGTGTGGCAAAAAGGAACAAACAGTCAGGGTGACTGCCATTCTAGAAAGGGTGGTCGAGGGAAGGTCTCCTTGAAGCAGATCCTGTGGGAGTGGAGAGGGTAAGTCACGGACTCTCTGGAGGAACGAAGATTCCAGGTGGAAATGCCTTAGTGGGTGTTAAACGCTTTAACGGGTGTTAGCCAGAAAGCCAGAATGGCTGGAGCTGAAGGGAGTAGAGGAGGCGGCTAGGAAAATGAGGTCAGAAGATGGAGAGCAGGGCCGGATCACGAGAGCGGGCACAGAGAACGAGGAGGGAATTGGATTTTTGGAAATAGATTGTGGCAAAATACAAAATATTAAAATACATAAAATAAAATATGAAACCATAAATGTACTACCCTTTACCCATTTTAAGTATGCCAGTTCAGTTAGTGTTAAATACATTTACATCATTGTTACAACCCGTCTCCAGGAACTCTCTGCATCTTGCAAAATTAACAACTCTATGCCATTTCAACAGTTCGCATTTCCTCTCTCCCTCTCGTCATGGCAACCGCCATTGTTTCTTTCTTGTCTCGTAAATGTAGTACTTTGGGTGTAATCTCATCTAAGTGGAATCACACAGTGTGTGTCCTTTTAGTGACAGACTTTTTCACTTTGCATAATGTCCTGTAATATTCATCCATGTTGTAGCATGGTCAGATTTTATCCTTCCTTCTTAACATTTGTAATATTCCATTGTTACGGCATAGACTACATTTAGCTTATCTGTTCACCTGTGGATGGACAACTTGGGTTGCTATAGTAATAATATTGCTGTAAATATGGGTATACGATTATCTCTTTGTGACCCTGCTTTTAATTGTTTTGGATATATACCCAGAATATGGGAATTACTGAATCATGTTGGAGATTCTGTTTTTGATTTATTTATTTTATTTTTAATTTTTGAGATGGAGTCTCGTTTTCTGTCACCCAGGCTGGAGTGCAGTGACACGATCTCTGCTCACTGCAACCTCCTGCTCCCTTGCACCATTAATTCCTCAAAGATGCAGGCCTGGATCCAACGCCTTTGGGGACGGGTACTCCTGCCCACAGGAAAGAGGTTGAGGAGACAATAATGTCAACGAGAATCATCATCTTTGCTGTGGAAAATGGTGTGCAGAGTATTCTGGTGCCTCTGCCAAGTGATTGTCGCATGCTAGCCTTCCCTAGTAGCTGGGATTACAGGCATTTGCCACCAAGCCCCGGCTAATTTTGATGTATTTTTAGTAGAGACGGGGTTTATCATGTTGGCCAGGCTGGTCTCAAACTCCTGCCTCAAGGTGATCGCACCTGCCTCAGCACTCCCCAAATGGCTGGGATTATAGGTGTGAGCCATGCACCTGGCCTGATTGGTTATTTAAATTCTGAGAGGGGGTATACTAATGTGTTGAAAACACACAGGGATGGGATCAGGTATAGGTGGGGAGGGAGAGCAAAAGTTGGTATTTAGAATATGTTACGTTTGAACAAACCTAATACACATTCCACATCCAAGTGGACATAGAGGAGTTATTTGAAGCTCAGCAAGACACCTGAGTTGGGAGATCAGGAATTTGTGGATCATCTGGATATATTTAGCATTATGCCACAGGGCTGCTGCCCTGATTTTTTTCCCCCTAGACAGTTTCGCTCTGTTGCCTCTAGGCACGACCTTGACTCACTGCAGACCTCTGCCTCCCGGGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAGCTGGGATTAACAGGTGTCCACCATCACGCCCGGCTAATTTTAGTGCTTTTAATGAGATGGGTTTCACACATGTTGCCAGGTTGGTCTTCAAACTCCTGACCTCAGGTGATCCACCTGCCTTGGCCTCCCCAAAGTGGCTGGACCAGGCGATGAGCCACTGCACCTCGGCCACCACTGCCTGCTTTATTGTACCGCTTCGGCAAGCTAAGAATGGTTTTCAATTTTGTTTTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCCAGGCTGGAGTGCAGTGGCACAATCTCAGCTCACTACAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAAGCCTCCCGAGTCACGCTGCGGACGTACAGTTGCCTGCCACCACGCCCAGCTATTATATTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGGCTGCCTGACTTTTTTTCCCCCTAACAGTTTCGCTCTTGTTGCCCAGGCACGACCTTGACTCACTGCACATCCTCTGCCTCCCGGGTGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAAGCTGGGTTACAGGTGTCCACCATCAACGCCCGGCTAATTTTAGTGCCTTATTAATAGAGATAGGGTTTCACCCATGTTGGCCAGGTGTCTCAAACTCCTGACCTCAGGTGATCCACACTGCCATTTGGCGCTCCTCAAAGTGCTGGCCTACGGCATGAGCCACTGCACCTGGCCATCCGACTGCCTGTTTTTGGTACTCCAGCTTGGGCAAGCTAAGAATGTTTTCACATTTTTGTTGTCTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCTCAGGCTGGAGTGCAGTGGCAGCAATCTCAGCTCACTACAAGCTTCCGCCTCCCGGGTGTCATCGGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACCTACAGTTGCTGCTACCACGCCCAGCTAATTTTTTGTTATGATTTTGATCATCTGATATATTTAGCATTTATAGCCATCAGGTGCTGCTGCCTGGACCTTTTTTTCCCCTAGAAGTTTCGTTCTTGTTGCCCAGGCCACGACTCTTGACTTATGCAACCTCTGCGCTCCCGGGGTTCAAGCGATTCTCTTGCCTCAGCCCCCCGAGTAGCTGGGATTATCAGGTGTCCACCCATCACTGGCCCGGCCTAATTCTTAGTCGCTGTTCTAAAGAGATGAGGTTTTCCATGTTGAGCCAGGTTGGTCTCAGAACTCCTGACTCAGGTGATCCACCTGCCTTTGGCCTCCCAAAGTGCTGGCCAGGATGAGCCAGCTGCACCTGGCCACCACTGCCTGTTTCTGTACCGCTTGGCAAGCCTAAGAGATGGTTTTTCACATTTTTGTTTCTTTTTTTTTGGAGTACGGAGTCTCACCATCTGTCACCCAGGCTGGATTGCAGTGGCACAATCTCAGGCTCACTACAACGCTCCGCCTCCCGGGTTACACAGCTCATTCTCCTGCCTCCAGCCTCCCCGAGTAGCTGGGACTAACAGTTGCCTGCCACCACGCCCAGCTAATTTTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGCTCGCCTGACTTTTTTTCCCCCTAGCCACAGTTTGCTCTTGTTGCCCAGGCACGACCTTACTCACTGCCAACCTCTGGCCTCGCCGGGTTCAAGCGAGTTCTCTTGACCTCAGCCCCCCGAGTAGCTGGGATTACAGGTGTCCACCATCAGCGCCCGGCTAATTTTAGTGCTTTTAATAAGAGATGGGTTTCACCATTTGGCCAGGTGGTCTCAAACTCCTGGACCTCAGGTGATCCACCTGCCTTGGCCTCCCAAAGTGCTGGGCCAGGCATGAGCCACTGAACCTGGCCACCACTTGCCTGTTTTTGTACCGCTTGGCAAGCCTAAGAATGGATTTTCACATTTTTGTTTCTTTGTTTTTTGAGAGACGGAGTCTCCACTCCTGTCAACCCAGGCTGGAGATGCAGTGGCACAATCTCACGCTCACTACAAGCTCCGCCTCCCGGGTTACGCCATTCTCACTGCCTCAGTCCTTCCCGAGTGAGCTCGGGCTACAGTTGCCTTGCCACCACGCCCAGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACTGTGGTATGGATTCTTCCTGAACTCGTTGATCCGCCTGCCTCGGCCTCCCAAAAGGTGCTGGGATTACAGGCATGAGCCACCGTGACCGGCCACTGCTGCCGTGTTTTTGTACTGCTTGGCATAGCTAAGAATGGTTTTCATCACATTGTGAATAGTTTTGAAGAAAAATTTTTCAAGAATACATTTTGTGGCACACGAAAATTATATAGAAATTCAAAGTTTTCAATGTCACAAATAAGAGGTTTTATATTGGAACATAGCATGCTCACTCATTTAGGTATTGTTACGGCTTGCTTCCACACTACAAGCAGCCAGGGTTCAGAGGTCATGGCAGAGACCAACGTGGCCCACAAAGTGTGAATGTCACTTCCCTTTGTACAAGCTGTTTGCCCTAAAACTCTTGGCTAAGCAGAGTGAGTCATGAGAGAAGAGAGAAGGTGCATGGACTGAGGTCTGTCAAGGGCCTGTCAAGAGCCAGTAACCGTTGCTGTGCGCTCAAGGATGCCAAGATGAGTGGCTTTGCTCCATGAGCAACAAAGCCCAGGGGCCCAGCAAGCCAAGGCTGCTTGCCTCTTTGTCCCCTGGGGCCAGCTGTGCATCTTGTGGATGGGCTGAGAGTTGAGCAACCCATAACAGGCCTCCTGACCCACTGTGAGATGGTGGCATGTGAAAGGACCAGCATCCAACAGTCTTGCCTCTTACTATATTAGTTAATTTCCTGGGGCTACAGGAGCTTATTTACTCAAACTGAGTGACTAAAACAATGGAATGGATTTTCTCTCGCAGTTCTAAGAGGGTATTATTCTTTCAACAATCAAGGTGACAGCACGGCCATGCTCCCGAAAGACAGCTCTAGGAAAAGCTCCTGGTTTCTAGCGGCTGCCTGCACTTCCTTGGCATTCCTTGAGCTTCAGCTGCATCATTCAGTGCTTGCTTCGGTACCACCGTGCCTTCATCCCTGGGTCGCTTCCATCGTCTCTATGTCCAAATGTTCGCATCTTTTATAAGGATGCTTAGTCATTGGATCCCAGGGCCCATCCCTAATCTGGTATGACTTCATAATTAATGTGAGTTGCATTGAAAAGACGCTGTTATCCAAATAAAGCCATCTCACACGTATGGGGACTAGGACGTTCAGACATATCTTTTTGCGGGACAAAATTCTACTCCACTATACTTCCCACACACATGCAGCATTTCCACGTGGTGAATCTAAGAGTATTTAGGGTTCTTGCGATAAAAGGGATATGGCCCGGTTGACTATCCTGGGGATAAGAAATCAAAAGAGAAAAAAACTCTAGTATTGGTGTTAAGACCCTGCAGTTTTACATTCATTTCCTGCACCACTCCCTGCTGCCTGCAAGGCAGGCCAGCTGCTTCACCTAGGGGCAGAATTCGGAGAAAGAATACGTCTCTCTGGATGTAACTACTGCGACTCAGGCAACCCACTAGTGGAGCTTCACAGGTGGTTCATCTGCCAAAGATTCTGAGGTTTTTAGCCGTGAGATGATAGGGTCAGAAACCGGGTGGTGCTCATGGGGGAAAGCAGCTACTGGAAGAGTCTAGATGCTGCTTCCCCTCAGGACTGTGATTGACCTTCAACTGGCCCCTCATCCCCAAGAACCTCAGCTTCTTCCTCT * AS:i:10650 NM:i:354 SA:Z:chr21,35351847,+,7658S4M1D43M1I22M2I7M1D25M1D8M1I8M1I5M1I14M1I8M1I43M1I27M1I18M1D9M1D15M1I40M1I33M1I26M1I10M1I29M1I12M1I4M1I5M1I13M1I18M1I28M1D11M1I9M1I2M1I8M1I4M1I3M1D11M1I63M1I2M1I11M1I23M1I3M1I46M1I20M1I18M1I6M1I6M2I6M1I18M1D26M1I7M1I3M1I9M1D9M1I1M1I8M2I39M1I14M1I5M1I27M1I15M1I8M1I24M1I2M2I12M1I29M1I57M1I17M1I2M1I2M1I54M1I2M2I30M1I6M1I21M1I58M1I13M1I23M1I8M1D13M1D11M1D6M2I15M1I20M1D30M1I47M1I16M1I4M1D13M1D4M1I2M1D9M1D4M1I28M1I17M1I4M1I4M1D11M1I13M2I9M1I22M1I10M1I9M1D12M1I16M1D22M1I4M1I30M1I10M1I14M1I4M1I7M1D17M1I17M1I13M1I5M1D10M1I22M1D25M1I8M1I10M1I20M1I18M1I15M1I21M1I15M1I15M1I13M1I7M1I28M1I10M1I5M1I5M1D26M1I6M1D18M1I8M1I6M1I14M1I33M,40,155;chr21,35351847,+,7076S4M1D1M1D31M1I4M1I10M1I2M1I8M1D8M1D22M1I6M1I9M1D12M1I5M1I47M1I10M1I7M2I6M1I6M1I5M1I3M1I2M1I3M1D7M1I5M1D9M1I15M1I9M1D19M1I25M1D8M1I43M1I6M1I4M1I18M1D13M1I11M1I1M1I37M1I11M1I17M1I3M1I2M1I13M1I6M1I17M1I36M2242S,22,51;chr21,35351854,+,6495S38M1I24M1D44M1I1M1I16M2I16M1I16M1I7M1D18M1I20M1I3M1I11M1I8M1I14M1D1M1D30M1I5M2I5M1I4M1I13M1I1M1I24M1I2M1I13M1I4M2I1M1I4M1I14M1D17M1I37M1I20M1I21M1I14M1I3M1I1M1I36M1I9M1D28M2828S,40,41;
read1 2048 chr21 35351847 40 7658S4M1D43M1I22M2I7M1D25M1D8M1I8M1I5M1I14M1I8M1I43M1I27M1I18M1D9M1D15M1I40M1I33M1I26M1I10M1I29M1I12M1I4M1I5M1I13M1I18M1I28M1D11M1I9M1I2M1I8M1I4M1I3M1D11M1I63M1I2M1I11M1I23M1I3M1I46M1I20M1I18M1I6M1I6M2I6M1I18M1D26M1I7M1I3M1I9M1D9M1I1M1I8M2I39M1I14M1I5M1I27M1I15M1I8M1I24M1I2M2I12M1I29M1I57M1I17M1I2M1I2M1I54M1I2M2I30M1I6M1I21M1I58M1I13M1I23M1I8M1D13M1D11M1D6M2I15M1I20M1D30M1I47M1I16M1I4M1D13M1D4M1I2M1D9M1D4M1I28M1I17M1I4M1I4M1D11M1I13M2I9M1I22M1I10M1I9M1D12M1I16M1D22M1I4M1I30M1I10M1I14M1I4M1I7M1D17M1I17M1I13M1I5M1D10M1I22M1D25M1I8M1I10M1I20M1I18M1I15M1I21M1I15M1I15M1I13M1I7M1I28M1I10M1I5M1I5M1D26M1I6M1D18M1I8M1I6M1I14M1I33M * 0 0 TCCTTGCCTTTCAGGTGCTTTAAGAGGGCTTATCGTTCTTTGACTCCCCTAGTAACTCAAAAGGGTGGCAAGATGCAACTCTGAGGCTTTCCAAGCTCTCTGCAAGCCTGCCTTCAGTAAGTCTGTGCACCACAAAGAAGCATAACTTATATCCTCTAGCTGAATTTACCTCCTGCTTCGAGCCCCTGTTTCCCATGTCATTTTAGGGGTCCAGATGTTTTTCCTGGAGGCATATACACACACACACTACACACACACAACACACACATCACACACACACACACACACACATATATACACACACACATTCCAGGGGCCTCTGAGGTGCCAAGACATGTGTGGGGTCCAATCTGGTTAACACTGATGTCCATGATCATTGAGTTCATTTTTTATATCAACTATGTGACACTTCCTGATAGTTTCCGTTCCTGTGTTAGAATTTGCAAAGTTGCCGACTATTTCTTTGAATGAAGAGTAGCTAGATCATGGGTCTACACCAGGTCATCAAGCAGCCGATTTCCCCTGTTGGAAGCTCCAAGCAAATTGTCAGCTCCAAGCATTGCCACACAGCTGTGGGTGTGCCACACTCCTTTTCCTTTTAATAAGATGATGATCTGCTAGTGTGTGAATGCTCTTGGAGTTTTATTTGTAGGTTTTTTCCTTGTATGTCGCAAATGTATCTATATTTCATCTTCCCTCTTGAGGGATATTTTCCATGGGTAGAGGATCTAGCGCTTTCTCTTTTGCGATTCCATGTGTGGCTTTAAAAAAAAGTCAGTTGACTGTTTATTTATGGCTTCTCTAAAGGTGATCTCTTTCTCCTAAGGACTGCTTTAAAAGCTTTCGCGTTCCCTCCCTCCCTTCCTCCCACCCCATCCCCCTTCTTCCTTTCCTTCCTCCCTCCCTCCTCCCTTCTGCTTCCTCCCTTTTCTCCCTGTCGTTTCCTCCTTTCTCCCATCCTCCCTCCTCCCTCTTTCCTTCTTTTTTCCCTTCCTCCCGCCCTCCTTCCTTCTTCCATCTTATATATTATAAATAATTTTCTTTCTTTCTTTATTTTTTTTTGAGATGGAGTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAACGGTGGTGATCTTGGCTTACTGCCAACCTCCACCTCCCTGGTTCAAGCGATTCACCTGCCTCAGCCTCCCTAGTAGCTGGGATTACAGGTGCCCGCCACCACACCCAGCTAATTTTTGTAATTGTAGTAGAGATGGGGTTTCACCATGGTGGGCCAGGCTGGTCTTGAACTCCTGAACTCAGGTAATCCACCCGCCTTGTCCTCCCAAAGTGCTGGAATTACAGGCATGAGCCACCACTCCCAGCCCTAATTAAAATATTTTCTTTCTGAGGCCCTTCCCTACCCTCTTGTACTTCTTTTGATACCGCCATCATAATGCATGTTAGGTGGACTCATCTGTGTACTCTATTACCCTCTCATCTGGTTTTTAATCTTTCTGTCTCCTTATACTGTAATCTCAGTGTTTCTTCTGCTTTAATTTTGGTATATGAATTATTCAGCTGTGTTCAAAGTGTGGTTCAAATGCGACTATATGCTTCTTTAAGTTTTTAGTTATTGTACTTCTCACCTCTAGAAGTTCTTCTGTGACACTTCTTATAGTTTCGCAGTTCTTGGGTAGAATTTGCAAACTTGTTGACTATTTCTTTGAAAAGAGTAGCTAGAATTGTTTTAGTCTGTGTATAGTGAGTATGAATATCTGAAACCTCTGTGAGTCTGTTTCTTTTGTCTCGCTAGCCCTACTCATGGCGTCCATGTTTTCCTGGATGTTTAGTTGGTTGTTCTTTGAATATGTCCAAACTCCCAGTTATTTCTGGGGAATACCCAAAGGCACACCTGTTCCTATCACCCAGTGAACTGCCATGTGTTTGTCTCCTGTCATGGTAGACATTTTGCATTCAGGGAGAGGCCTCTGCTCTCTGCAGAACAGTGTGAAATGCACCTCATTTTTGCCTTCAATGAAGGTTGTCTCTTGCTTGGCACCACCACTTCCTCAAATGACTAATGCCACTCTTGCTCACAGTGCTAAGGCGCTAAGGAGTTTATCAGAGGCTAGAGTGATTCTGCATCCTCTGGGGTTCTCAGGAAGCGAGGCCACAGGGCCATCTGTGCATGTAGTGACAGTGGGGTGGGGTGGATGAGCAGTTGGCAGTGGTGGGCACCTATGCTGCTGGCGCCACAGCTTTTTATATCTTGGTGAAAACAGACGCCCTTGCGTTTTCACTTGTAGATTCTCCGGCTACATCCACAAGAACAAATTCTGTCACAGAGGCCAGATAGACTATCAGTGTAATGGGCCCTTTCCCCTTTGATGATAGCAGCTTTTTTCGGGGGAGCAGGGGTTGCCAAACTTCTACGCCTTATTTTATCTTCCTTTCTGAGTTCTCCCCAGAGGCTGCTGGGTCCACCTCTCCCTCTGCCAGACAGACAGGCTCAGGACATAGCAAGAACGGAAGGGGTGTGGGGGTTGGTGGGAGGTATTAAGTTGGGGAAACGACAGCTCTTGTCTTTGTAGATTACCAGAACTGACACACGTACACACACGTACACTCACGCTCACTCACTCACTCATCTATCATCTATTTTTGGCCTAAGCTGCCTTTGGACACTTCCTTCGAAAAGCACATGAACTCTTCGGAGTTCTCCTGTTCCACCTTGGTAAATTTCCTATAGCCAACGCACTGAAAGTCCCTGCTGCCCTCCTTCCTCTGAGCTTGTGGGGCCCACAGATCCCCTGCTCCATTTCCTGCTTCATTTCAGCTGATGGTGAGCTTCCAGGGCAGGCTTGTAGGAAGGGCGGGCTAAGGCTGGGGAACTGCAGCACCCACCACCACCCGCCCGCCCCAGTGCTTGTTGCCCCTAGCCTCTGTCTCTCCTCGCTGTGCCCTTCCCTTAAGCCCCACTCTTGGCCTCCCACAAAGACAAGAGTTTGTTCTGTTTTTATATTGATAGGATGAACTCCCTCGTTCTAATACCTATCTGAATAGCCTGAGCAATTACATTTACAACCTCATGAAAAATACACAGCACTTGTCACGATGAATGATGTTTACCGTGAATAATTGCAGTTTTGAGTTCAAACATCCTTCTATAGTCCAAGAATGAGTAAATATCCCTATTCCCTACCCCTCCCCATTGCATTTGGGTTTGACATGACATGCAATCATTGTGAGTTTTACTGCCTGGGGTAGAATTGTTTTTGCCTGTATTGCCATTGCCAATTGACTGGAAGGACAAAAAAAGGAAACTTACCAATTGAGCAGTTTCTAGATGAACTTAAATATCTCAGAAATCTTGAAGCAATGAATGAACTATAACTTTCTGAAGTTGCAAAAATGATTCAAGTCGGAAGTGACCCATGGGAGCAACCTGGTCCTTAATTAGGACTGGAAAGAAAACGGTAGGCCCATGCGAGGTGGAACAGTGGCTTCCCCAAGGTCACACTGCAAGTGAGTGGTGGCACTAGTCACCCAGGAGTCCTCCTGACTCCATGGTATCCTGACCCCAGACCAGAGCCTTATTTGTGGTTAAAGAACGTGGAAAAACAGCTTATGTTTGAATTTTAGAAATCATGCCAGTAGCTAAAGATCTGCATTCTCATGAATATTGAGCTTTGCGTTGTGCGGGTTGCTACGAATTTTGTAACTATTTTCTCCTAGAGCTCTCAGTATTTTACATATGACCAATTCCATTCTATTATTGTCCCGGGAAAAGAGTGTGCATTTACTGAGCAGTAAGAGGGTGATTTGAAGTCCCTGGGGTCCCCCACCCTTGTCTTTCTATGTGAGATTGTATGTGCAGGGCTCACATTTATGTCTCCTCCAGGCAGCTCATGTGCACAGACTAGTTGTATTTATTAGAGCACCTACTGTGGTGCCATGGAAGCTATGTGGTAAGCTAAGCAGGACAAAAACTCCTGCTCTCACAAGAAGAAAGAATAAACAAGCAGACAATTGCCCGTATAATGTCAGCCTGGTGTGATGGCTCATCTCCTGGAATACCCTAGCACTTTGGGAGGTGACGATGGGAGGGATTGGCTTTAACTTCGGGAGTTCAAGATAAAGCCTGGGCAACCAAGACCCTTCTCTACAAAAAAAATCAAAAAATTAGACTGGGGGTCATGGCATGAGTCTCTGGCCCCTCGGGACCAGAGGCTCGGGAGCTGAGGCGTGGTTTTCACTGAGCCTGGGAGCGTTTGAGGCTGCAGTGAGCTGTGATCACAACCACCTGCACTGCCAGCCTGGCCACAGAGCGAGACCCTGTCCTCTAAATTAAACAACAACCCTAATGTCAAGATTAGGAAGTGTGGCAAAAAGGAACAAACAGTCAGGGTGACTGCCATTCTAGAAAGGGTGGTCGAGGGAAGGTCTCCTTGAAGCAGATCCTGTGGGAGTGGAGAGGGTAAGTCACGGACTCTCTGGAGGAACGAAGATTCCAGGTGGAAATGCCTTAGTGGGTGTTAAACGCTTTAACGGGTGTTAGCCAGAAAGCCAGAATGGCTGGAGCTGAAGGGAGTAGAGGAGGCGGCTAGGAAAATGAGGTCAGAAGATGGAGAGCAGGGCCGGATCACGAGAGCGGGCACAGAGAACGAGGAGGGAATTGGATTTTTGGAAATAGATTGTGGCAAAATACAAAATATTAAAATACATAAAATAAAATATGAAACCATAAATGTACTACCCTTTACCCATTTTAAGTATGCCAGTTCAGTTAGTGTTAAATACATTTACATCATTGTTACAACCCGTCTCCAGGAACTCTCTGCATCTTGCAAAATTAACAACTCTATGCCATTTCAACAGTTCGCATTTCCTCTCTCCCTCTCGTCATGGCAACCGCCATTGTTTCTTTCTTGTCTCGTAAATGTAGTACTTTGGGTGTAATCTCATCTAAGTGGAATCACACAGTGTGTGTCCTTTTAGTGACAGACTTTTTCACTTTGCATAATGTCCTGTAATATTCATCCATGTTGTAGCATGGTCAGATTTTATCCTTCCTTCTTAACATTTGTAATATTCCATTGTTACGGCATAGACTACATTTAGCTTATCTGTTCACCTGTGGATGGACAACTTGGGTTGCTATAGTAATAATATTGCTGTAAATATGGGTATACGATTATCTCTTTGTGACCCTGCTTTTAATTGTTTTGGATATATACCCAGAATATGGGAATTACTGAATCATGTTGGAGATTCTGTTTTTGATTTATTTATTTTATTTTTAATTTTTGAGATGGAGTCTCGTTTTCTGTCACCCAGGCTGGAGTGCAGTGACACGATCTCTGCTCACTGCAACCTCCTGCTCCCTTGCACCATTAATTCCTCAAAGATGCAGGCCTGGATCCAACGCCTTTGGGGACGGGTACTCCTGCCCACAGGAAAGAGGTTGAGGAGACAATAATGTCAACGAGAATCATCATCTTTGCTGTGGAAAATGGTGTGCAGAGTATTCTGGTGCCTCTGCCAAGTGATTGTCGCATGCTAGCCTTCCCTAGTAGCTGGGATTACAGGCATTTGCCACCAAGCCCCGGCTAATTTTGATGTATTTTTAGTAGAGACGGGGTTTATCATGTTGGCCAGGCTGGTCTCAAACTCCTGCCTCAAGGTGATCGCACCTGCCTCAGCACTCCCCAAATGGCTGGGATTATAGGTGTGAGCCATGCACCTGGCCTGATTGGTTATTTAAATTCTGAGAGGGGGTATACTAATGTGTTGAAAACACACAGGGATGGGATCAGGTATAGGTGGGGAGGGAGAGCAAAAGTTGGTATTTAGAATATGTTACGTTTGAACAAACCTAATACACATTCCACATCCAAGTGGACATAGAGGAGTTATTTGAAGCTCAGCAAGACACCTGAGTTGGGAGATCAGGAATTTGTGGATCATCTGGATATATTTAGCATTATGCCACAGGGCTGCTGCCCTGATTTTTTTCCCCCTAGACAGTTTCGCTCTGTTGCCTCTAGGCACGACCTTGACTCACTGCAGACCTCTGCCTCCCGGGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAGCTGGGATTAACAGGTGTCCACCATCACGCCCGGCTAATTTTAGTGCTTTTAATGAGATGGGTTTCACACATGTTGCCAGGTTGGTCTTCAAACTCCTGACCTCAGGTGATCCACCTGCCTTGGCCTCCCCAAAGTGGCTGGACCAGGCGATGAGCCACTGCACCTCGGCCACCACTGCCTGCTTTATTGTACCGCTTCGGCAAGCTAAGAATGGTTTTCAATTTTGTTTTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCCAGGCTGGAGTGCAGTGGCACAATCTCAGCTCACTACAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAAGCCTCCCGAGTCACGCTGCGGACGTACAGTTGCCTGCCACCACGCCCAGCTATTATATTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGGCTGCCTGACTTTTTTTCCCCCTAACAGTTTCGCTCTTGTTGCCCAGGCACGACCTTGACTCACTGCACATCCTCTGCCTCCCGGGTGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAAGCTGGGTTACAGGTGTCCACCATCAACGCCCGGCTAATTTTAGTGCCTTATTAATAGAGATAGGGTTTCACCCATGTTGGCCAGGTGTCTCAAACTCCTGACCTCAGGTGATCCACACTGCCATTTGGCGCTCCTCAAAGTGCTGGCCTACGGCATGAGCCACTGCACCTGGCCATCCGACTGCCTGTTTTTGGTACTCCAGCTTGGGCAAGCTAAGAATGTTTTCACATTTTTGTTGTCTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCTCAGGCTGGAGTGCAGTGGCAGCAATCTCAGCTCACTACAAGCTTCCGCCTCCCGGGTGTCATCGGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACCTACAGTTGCTGCTACCACGCCCAGCTAATTTTTTGTTATGATTTTGATCATCTGATATATTTAGCATTTATAGCCATCAGGTGCTGCTGCCTGGACCTTTTTTTCCCCTAGAAGTTTCGTTCTTGTTGCCCAGGCCACGACTCTTGACTTATGCAACCTCTGCGCTCCCGGGGTTCAAGCGATTCTCTTGCCTCAGCCCCCCGAGTAGCTGGGATTATCAGGTGTCCACCCATCACTGGCCCGGCCTAATTCTTAGTCGCTGTTCTAAAGAGATGAGGTTTTCCATGTTGAGCCAGGTTGGTCTCAGAACTCCTGACTCAGGTGATCCACCTGCCTTTGGCCTCCCAAAGTGCTGGCCAGGATGAGCCAGCTGCACCTGGCCACCACTGCCTGTTTCTGTACCGCTTGGCAAGCCTAAGAGATGGTTTTTCACATTTTTGTTTCTTTTTTTTTGGAGTACGGAGTCTCACCATCTGTCACCCAGGCTGGATTGCAGTGGCACAATCTCAGGCTCACTACAACGCTCCGCCTCCCGGGTTACACAGCTCATTCTCCTGCCTCCAGCCTCCCCGAGTAGCTGGGACTAACAGTTGCCTGCCACCACGCCCAGCTAATTTTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGCTCGCCTGACTTTTTTTCCCCCTAGCCACAGTTTGCTCTTGTTGCCCAGGCACGACCTTACTCACTGCCAACCTCTGGCCTCGCCGGGTTCAAGCGAGTTCTCTTGACCTCAGCCCCCCGAGTAGCTGGGATTACAGGTGTCCACCATCAGCGCCCGGCTAATTTTAGTGCTTTTAATAAGAGATGGGTTTCACCATTTGGCCAGGTGGTCTCAAACTCCTGGACCTCAGGTGATCCACCTGCCTTGGCCTCCCAAAGTGCTGGGCCAGGCATGAGCCACTGAACCTGGCCACCACTTGCCTGTTTTTGTACCGCTTGGCAAGCCTAAGAATGGATTTTCACATTTTTGTTTCTTTGTTTTTTGAGAGACGGAGTCTCCACTCCTGTCAACCCAGGCTGGAGATGCAGTGGCACAATCTCACGCTCACTACAAGCTCCGCCTCCCGGGTTACGCCATTCTCACTGCCTCAGTCCTTCCCGAGTGAGCTCGGGCTACAGTTGCCTTGCCACCACGCCCAGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACTGTGGTATGGATTCTTCCTGAACTCGTTGATCCGCCTGCCTCGGCCTCCCAAAAGGTGCTGGGATTACAGGCATGAGCCACCGTGACCGGCCACTGCTGCCGTGTTTTTGTACTGCTTGGCATAGCTAAGAATGGTTTTCATCACATTGTGAATAGTTTTGAAGAAAAATTTTTCAAGAATACATTTTGTGGCACACGAAAATTATATAGAAATTCAAAGTTTTCAATGTCACAAATAAGAGGTTTTATATTGGAACATAGCATGCTCACTCATTTAGGTATTGTTACGGCTTGCTTCCACACTACAAGCAGCCAGGGTTCAGAGGTCATGGCAGAGACCAACGTGGCCCACAAAGTGTGAATGTCACTTCCCTTTGTACAAGCTGTTTGCCCTAAAACTCTTGGCTAAGCAGAGTGAGTCATGAGAGAAGAGAGAAGGTGCATGGACTGAGGTCTGTCAAGGGCCTGTCAAGAGCCAGTAACCGTTGCTGTGCGCTCAAGGATGCCAAGATGAGTGGCTTTGCTCCATGAGCAACAAAGCCCAGGGGCCCAGCAAGCCAAGGCTGCTTGCCTCTTTGTCCCCTGGGGCCAGCTGTGCATCTTGTGGATGGGCTGAGAGTTGAGCAACCCATAACAGGCCTCCTGACCCACTGTGAGATGGTGGCATGTGAAAGGACCAGCATCCAACAGTCTTGCCTCTTACTATATTAGTTAATTTCCTGGGGCTACAGGAGCTTATTTACTCAAACTGAGTGACTAAAACAATGGAATGGATTTTCTCTCGCAGTTCTAAGAGGGTATTATTCTTTCAACAATCAAGGTGACAGCACGGCCATGCTCCCGAAAGACAGCTCTAGGAAAAGCTCCTGGTTTCTAGCGGCTGCCTGCACTTCCTTGGCATTCCTTGAGCTTCAGCTGCATCATTCAGTGCTTGCTTCGGTACCACCGTGCCTTCATCCCTGGGTCGCTTCCATCGTCTCTATGTCCAAATGTTCGCATCTTTTATAAGGATGCTTAGTCATTGGATCCCAGGGCCCATCCCTAATCTGGTATGACTTCATAATTAATGTGAGTTGCATTGAAAAGACGCTGTTATCCAAATAAAGCCATCTCACACGTATGGGGACTAGGACGTTCAGACATATCTTTTTGCGGGACAAAATTCTACTCCACTATACTTCCCACACACATGCAGCATTTCCACGTGGTGAATCTAAGAGTATTTAGGGTTCTTGCGATAAAAGGGATATGGCCCGGTTGACTATCCTGGGGATAAGAAATCAAAAGAGAAAAAAACTCTAGTATTGGTGTTAAGACCCTGCAGTTTTACATTCATTTCCTGCACCACTCCCTGCTGCCTGCAAGGCAGGCCAGCTGCTTCACCTAGGGGCAGAATTCGGAGAAAGAATACGTCTCTCTGGATGTAACTACTGCGACTCAGGCAACCCACTAGTGGAGCTTCACAGGTGGTTCATCTGCCAAAGATTCTGAGGTTTTTAGCCGTGAGATGATAGGGTCAGAAACCGGGTGGTGCTCATGGGGGAAAGCAGCTACTGGAAGAGTCTAGATGCTGCTTCCCCTCAGGACTGTGATTGACCTTCAACTGGCCCCTCATCCCCAAGAACCTCAGCTTCTTCCTCT * AS:i:3450 NM:i:155 SA:Z:chr21,35346115,+,33M1I35M1D13M1D4M1I16M1D15M1I14M1I12M1D3M1D39M1D25M1I33M1I10M1I9M1I78M1I66M1I9M1D7M1I37M2I28M1I12M1I6M1I34M1I6M1I17M2I21M1I20M1I29M1I5M1I5M1I12M2I52M1I5M1I7M1I8M1I63M1D8M1I12M1I4M1I59M1D11M1I9M1I8M1D4M2I7M1D16M1D55M1D10M1I4M1I17M1I53M1I17M1I124M1I96M1I3M1I14M1I5M1I2M1I8M2I3M1I2M1I23M1I21M1I123M1I3M1I5M1D7M1I7M1I59M1I84M1I39M1I20M1I28M1I15M1I4M1I12M1I26M1D44M1I3M1I47M1I37M1I3M1D64M1I5M1D65M1I29M1I59M1I3M1I34M1D18M1D15M1D17M1I5M1I52M1D3M1I22M1I56M1I5M1I12M1D23M1I15M1I5M1I53M2I19M1D20M1I15M1I4M1D24M1I12M1I21M1I95M2I30M1I4M1D21M1I6M1I23M1I12M1I41M1I7M1I20M2I11M1D19M1I8M1I16M1D18M2I7M1D19M1I13M1I19M1I7M1I33M1I35M1I10M1I8M1I3M1I16M2I8M1I13M1I29M1I11M1I14M1I17M1I37M1I24M1D38M1I7M1I6M2I95M1D52M1I14M1I16M1I19M1I1M1D35M1I2M1D23M1I1M1I12M1I17M1I3M1I77M1I18M1I3M1I2M1I2M1I9M1I9M1I2M1I10M1I13M1I6M1I2M1I21M1I52M1D2M1I28M1I10M2I28M1I5M1I8M1I15M1I22M1D7M1I19M1I43M1D7M1D9M1I5M1D4M1D12M1I1M1I26M1I4M1I7M1I7M1D21M1I7M1I5M1D5M1I12M1I27M2I32M1I17M1I21M1I13M1D15M1I81M1I19M1D2M1I14M1I8M1I15M1I4M1I38M1I23M1I9M1I12M1I7M1D10M1I6M1I14M1I8M1I28M1I13M1I26M1I35M1I9M1D17M1I8M1I6M1D7M1D6M1I5M1I2M1I38M1I11M1D21M1I25M1D10M2I17M1D15M1I3M1I42M1I17M1D79M1I2M1I17M1I26M1I30M2I52M1I4M1I1M1D16M1I6M1I18M1D19M2I11M1I25M1I19M1D3M1I2M1I16M1I10M1D4M2I15M1I2M1D4M1I37M1I13M2I25M1D32M1D4M1I8M1I13M1I2M1I6M1I1M1D74M1I8M1I14M1I28M1I27M1I37M1D19M1I14M1I5M1I20M1I13M1D4M1D15M1I5M1D27M1D7M1I1M1I23M1I33M1I26M1I44M1D14M1I6M1D12M1I39M1I8M1I5M1I6M1I16M1I15M1I3M1I11M1I22M1D1M1D8M1D110M1I12M1I1M1I4M1I4M1I28M2I15M3405S,60,354;chr21,35351847,+,7076S4M1D1M1D31M1I4M1I10M1I2M1I8M1D8M1D22M1I6M1I9M1D12M1I5M1I47M1I10M1I7M2I6M1I6M1I5M1I3M1I2M1I3M1D7M1I5M1D9M1I15M1I9M1D19M1I25M1D8M1I43M1I6M1I4M1I18M1D13M1I11M1I1M1I37M1I11M1I17M1I3M1I2M1I13M1I6M1I17M1I36M2242S,22,51;chr21,35351854,+,6495S38M1I24M1D44M1I1M1I16M2I16M1I16M1I7M1D18M1I20M1I3M1I11M1I8M1I14M1D1M1D30M1I5M2I5M1I4M1I13M1I1M1I24M1I2M1I13M1I4M2I1M1I4M1I14M1D17M1I37M1I20M1I21M1I14M1I3M1I1M1I36M1I9M1D28M2828S,40,41;
read1 2048 chr21 35351847 22 7076S4M1D1M1D31M1I4M1I10M1I2M1I8M1D8M1D22M1I6M1I9M1D12M1I5M1I47M1I10M1I7M2I6M1I6M1I5M1I3M1I2M1I3M1D7M1I5M1D9M1I15M1I9M1D19M1I25M1D8M1I43M1I6M1I4M1I18M1D13M1I11M1I1M1I37M1I11M1I17M1I3M1I2M1I13M1I6M1I17M1I36M2242S * 0 0 TCCTTGCCTTTCAGGTGCTTTAAGAGGGCTTATCGTTCTTTGACTCCCCTAGTAACTCAAAAGGGTGGCAAGATGCAACTCTGAGGCTTTCCAAGCTCTCTGCAAGCCTGCCTTCAGTAAGTCTGTGCACCACAAAGAAGCATAACTTATATCCTCTAGCTGAATTTACCTCCTGCTTCGAGCCCCTGTTTCCCATGTCATTTTAGGGGTCCAGATGTTTTTCCTGGAGGCATATACACACACACACTACACACACACAACACACACATCACACACACACACACACACACATATATACACACACACATTCCAGGGGCCTCTGAGGTGCCAAGACATGTGTGGGGTCCAATCTGGTTAACACTGATGTCCATGATCATTGAGTTCATTTTTTATATCAACTATGTGACACTTCCTGATAGTTTCCGTTCCTGTGTTAGAATTTGCAAAGTTGCCGACTATTTCTTTGAATGAAGAGTAGCTAGATCATGGGTCTACACCAGGTCATCAAGCAGCCGATTTCCCCTGTTGGAAGCTCCAAGCAAATTGTCAGCTCCAAGCATTGCCACACAGCTGTGGGTGTGCCACACTCCTTTTCCTTTTAATAAGATGATGATCTGCTAGTGTGTGAATGCTCTTGGAGTTTTATTTGTAGGTTTTTTCCTTGTATGTCGCAAATGTATCTATATTTCATCTTCCCTCTTGAGGGATATTTTCCATGGGTAGAGGATCTAGCGCTTTCTCTTTTGCGATTCCATGTGTGGCTTTAAAAAAAAGTCAGTTGACTGTTTATTTATGGCTTCTCTAAAGGTGATCTCTTTCTCCTAAGGACTGCTTTAAAAGCTTTCGCGTTCCCTCCCTCCCTTCCTCCCACCCCATCCCCCTTCTTCCTTTCCTTCCTCCCTCCCTCCTCCCTTCTGCTTCCTCCCTTTTCTCCCTGTCGTTTCCTCCTTTCTCCCATCCTCCCTCCTCCCTCTTTCCTTCTTTTTTCCCTTCCTCCCGCCCTCCTTCCTTCTTCCATCTTATATATTATAAATAATTTTCTTTCTTTCTTTATTTTTTTTTGAGATGGAGTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAACGGTGGTGATCTTGGCTTACTGCCAACCTCCACCTCCCTGGTTCAAGCGATTCACCTGCCTCAGCCTCCCTAGTAGCTGGGATTACAGGTGCCCGCCACCACACCCAGCTAATTTTTGTAATTGTAGTAGAGATGGGGTTTCACCATGGTGGGCCAGGCTGGTCTTGAACTCCTGAACTCAGGTAATCCACCCGCCTTGTCCTCCCAAAGTGCTGGAATTACAGGCATGAGCCACCACTCCCAGCCCTAATTAAAATATTTTCTTTCTGAGGCCCTTCCCTACCCTCTTGTACTTCTTTTGATACCGCCATCATAATGCATGTTAGGTGGACTCATCTGTGTACTCTATTACCCTCTCATCTGGTTTTTAATCTTTCTGTCTCCTTATACTGTAATCTCAGTGTTTCTTCTGCTTTAATTTTGGTATATGAATTATTCAGCTGTGTTCAAAGTGTGGTTCAAATGCGACTATATGCTTCTTTAAGTTTTTAGTTATTGTACTTCTCACCTCTAGAAGTTCTTCTGTGACACTTCTTATAGTTTCGCAGTTCTTGGGTAGAATTTGCAAACTTGTTGACTATTTCTTTGAAAAGAGTAGCTAGAATTGTTTTAGTCTGTGTATAGTGAGTATGAATATCTGAAACCTCTGTGAGTCTGTTTCTTTTGTCTCGCTAGCCCTACTCATGGCGTCCATGTTTTCCTGGATGTTTAGTTGGTTGTTCTTTGAATATGTCCAAACTCCCAGTTATTTCTGGGGAATACCCAAAGGCACACCTGTTCCTATCACCCAGTGAACTGCCATGTGTTTGTCTCCTGTCATGGTAGACATTTTGCATTCAGGGAGAGGCCTCTGCTCTCTGCAGAACAGTGTGAAATGCACCTCATTTTTGCCTTCAATGAAGGTTGTCTCTTGCTTGGCACCACCACTTCCTCAAATGACTAATGCCACTCTTGCTCACAGTGCTAAGGCGCTAAGGAGTTTATCAGAGGCTAGAGTGATTCTGCATCCTCTGGGGTTCTCAGGAAGCGAGGCCACAGGGCCATCTGTGCATGTAGTGACAGTGGGGTGGGGTGGATGAGCAGTTGGCAGTGGTGGGCACCTATGCTGCTGGCGCCACAGCTTTTTATATCTTGGTGAAAACAGACGCCCTTGCGTTTTCACTTGTAGATTCTCCGGCTACATCCACAAGAACAAATTCTGTCACAGAGGCCAGATAGACTATCAGTGTAATGGGCCCTTTCCCCTTTGATGATAGCAGCTTTTTTCGGGGGAGCAGGGGTTGCCAAACTTCTACGCCTTATTTTATCTTCCTTTCTGAGTTCTCCCCAGAGGCTGCTGGGTCCACCTCTCCCTCTGCCAGACAGACAGGCTCAGGACATAGCAAGAACGGAAGGGGTGTGGGGGTTGGTGGGAGGTATTAAGTTGGGGAAACGACAGCTCTTGTCTTTGTAGATTACCAGAACTGACACACGTACACACACGTACACTCACGCTCACTCACTCACTCATCTATCATCTATTTTTGGCCTAAGCTGCCTTTGGACACTTCCTTCGAAAAGCACATGAACTCTTCGGAGTTCTCCTGTTCCACCTTGGTAAATTTCCTATAGCCAACGCACTGAAAGTCCCTGCTGCCCTCCTTCCTCTGAGCTTGTGGGGCCCACAGATCCCCTGCTCCATTTCCTGCTTCATTTCAGCTGATGGTGAGCTTCCAGGGCAGGCTTGTAGGAAGGGCGGGCTAAGGCTGGGGAACTGCAGCACCCACCACCACCCGCCCGCCCCAGTGCTTGTTGCCCCTAGCCTCTGTCTCTCCTCGCTGTGCCCTTCCCTTAAGCCCCACTCTTGGCCTCCCACAAAGACAAGAGTTTGTTCTGTTTTTATATTGATAGGATGAACTCCCTCGTTCTAATACCTATCTGAATAGCCTGAGCAATTACATTTACAACCTCATGAAAAATACACAGCACTTGTCACGATGAATGATGTTTACCGTGAATAATTGCAGTTTTGAGTTCAAACATCCTTCTATAGTCCAAGAATGAGTAAATATCCCTATTCCCTACCCCTCCCCATTGCATTTGGGTTTGACATGACATGCAATCATTGTGAGTTTTACTGCCTGGGGTAGAATTGTTTTTGCCTGTATTGCCATTGCCAATTGACTGGAAGGACAAAAAAAGGAAACTTACCAATTGAGCAGTTTCTAGATGAACTTAAATATCTCAGAAATCTTGAAGCAATGAATGAACTATAACTTTCTGAAGTTGCAAAAATGATTCAAGTCGGAAGTGACCCATGGGAGCAACCTGGTCCTTAATTAGGACTGGAAAGAAAACGGTAGGCCCATGCGAGGTGGAACAGTGGCTTCCCCAAGGTCACACTGCAAGTGAGTGGTGGCACTAGTCACCCAGGAGTCCTCCTGACTCCATGGTATCCTGACCCCAGACCAGAGCCTTATTTGTGGTTAAAGAACGTGGAAAAACAGCTTATGTTTGAATTTTAGAAATCATGCCAGTAGCTAAAGATCTGCATTCTCATGAATATTGAGCTTTGCGTTGTGCGGGTTGCTACGAATTTTGTAACTATTTTCTCCTAGAGCTCTCAGTATTTTACATATGACCAATTCCATTCTATTATTGTCCCGGGAAAAGAGTGTGCATTTACTGAGCAGTAAGAGGGTGATTTGAAGTCCCTGGGGTCCCCCACCCTTGTCTTTCTATGTGAGATTGTATGTGCAGGGCTCACATTTATGTCTCCTCCAGGCAGCTCATGTGCACAGACTAGTTGTATTTATTAGAGCACCTACTGTGGTGCCATGGAAGCTATGTGGTAAGCTAAGCAGGACAAAAACTCCTGCTCTCACAAGAAGAAAGAATAAACAAGCAGACAATTGCCCGTATAATGTCAGCCTGGTGTGATGGCTCATCTCCTGGAATACCCTAGCACTTTGGGAGGTGACGATGGGAGGGATTGGCTTTAACTTCGGGAGTTCAAGATAAAGCCTGGGCAACCAAGACCCTTCTCTACAAAAAAAATCAAAAAATTAGACTGGGGGTCATGGCATGAGTCTCTGGCCCCTCGGGACCAGAGGCTCGGGAGCTGAGGCGTGGTTTTCACTGAGCCTGGGAGCGTTTGAGGCTGCAGTGAGCTGTGATCACAACCACCTGCACTGCCAGCCTGGCCACAGAGCGAGACCCTGTCCTCTAAATTAAACAACAACCCTAATGTCAAGATTAGGAAGTGTGGCAAAAAGGAACAAACAGTCAGGGTGACTGCCATTCTAGAAAGGGTGGTCGAGGGAAGGTCTCCTTGAAGCAGATCCTGTGGGAGTGGAGAGGGTAAGTCACGGACTCTCTGGAGGAACGAAGATTCCAGGTGGAAATGCCTTAGTGGGTGTTAAACGCTTTAACGGGTGTTAGCCAGAAAGCCAGAATGGCTGGAGCTGAAGGGAGTAGAGGAGGCGGCTAGGAAAATGAGGTCAGAAGATGGAGAGCAGGGCCGGATCACGAGAGCGGGCACAGAGAACGAGGAGGGAATTGGATTTTTGGAAATAGATTGTGGCAAAATACAAAATATTAAAATACATAAAATAAAATATGAAACCATAAATGTACTACCCTTTACCCATTTTAAGTATGCCAGTTCAGTTAGTGTTAAATACATTTACATCATTGTTACAACCCGTCTCCAGGAACTCTCTGCATCTTGCAAAATTAACAACTCTATGCCATTTCAACAGTTCGCATTTCCTCTCTCCCTCTCGTCATGGCAACCGCCATTGTTTCTTTCTTGTCTCGTAAATGTAGTACTTTGGGTGTAATCTCATCTAAGTGGAATCACACAGTGTGTGTCCTTTTAGTGACAGACTTTTTCACTTTGCATAATGTCCTGTAATATTCATCCATGTTGTAGCATGGTCAGATTTTATCCTTCCTTCTTAACATTTGTAATATTCCATTGTTACGGCATAGACTACATTTAGCTTATCTGTTCACCTGTGGATGGACAACTTGGGTTGCTATAGTAATAATATTGCTGTAAATATGGGTATACGATTATCTCTTTGTGACCCTGCTTTTAATTGTTTTGGATATATACCCAGAATATGGGAATTACTGAATCATGTTGGAGATTCTGTTTTTGATTTATTTATTTTATTTTTAATTTTTGAGATGGAGTCTCGTTTTCTGTCACCCAGGCTGGAGTGCAGTGACACGATCTCTGCTCACTGCAACCTCCTGCTCCCTTGCACCATTAATTCCTCAAAGATGCAGGCCTGGATCCAACGCCTTTGGGGACGGGTACTCCTGCCCACAGGAAAGAGGTTGAGGAGACAATAATGTCAACGAGAATCATCATCTTTGCTGTGGAAAATGGTGTGCAGAGTATTCTGGTGCCTCTGCCAAGTGATTGTCGCATGCTAGCCTTCCCTAGTAGCTGGGATTACAGGCATTTGCCACCAAGCCCCGGCTAATTTTGATGTATTTTTAGTAGAGACGGGGTTTATCATGTTGGCCAGGCTGGTCTCAAACTCCTGCCTCAAGGTGATCGCACCTGCCTCAGCACTCCCCAAATGGCTGGGATTATAGGTGTGAGCCATGCACCTGGCCTGATTGGTTATTTAAATTCTGAGAGGGGGTATACTAATGTGTTGAAAACACACAGGGATGGGATCAGGTATAGGTGGGGAGGGAGAGCAAAAGTTGGTATTTAGAATATGTTACGTTTGAACAAACCTAATACACATTCCACATCCAAGTGGACATAGAGGAGTTATTTGAAGCTCAGCAAGACACCTGAGTTGGGAGATCAGGAATTTGTGGATCATCTGGATATATTTAGCATTATGCCACAGGGCTGCTGCCCTGATTTTTTTCCCCCTAGACAGTTTCGCTCTGTTGCCTCTAGGCACGACCTTGACTCACTGCAGACCTCTGCCTCCCGGGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAGCTGGGATTAACAGGTGTCCACCATCACGCCCGGCTAATTTTAGTGCTTTTAATGAGATGGGTTTCACACATGTTGCCAGGTTGGTCTTCAAACTCCTGACCTCAGGTGATCCACCTGCCTTGGCCTCCCCAAAGTGGCTGGACCAGGCGATGAGCCACTGCACCTCGGCCACCACTGCCTGCTTTATTGTACCGCTTCGGCAAGCTAAGAATGGTTTTCAATTTTGTTTTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCCAGGCTGGAGTGCAGTGGCACAATCTCAGCTCACTACAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAAGCCTCCCGAGTCACGCTGCGGACGTACAGTTGCCTGCCACCACGCCCAGCTATTATATTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGGCTGCCTGACTTTTTTTCCCCCTAACAGTTTCGCTCTTGTTGCCCAGGCACGACCTTGACTCACTGCACATCCTCTGCCTCCCGGGTGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAAGCTGGGTTACAGGTGTCCACCATCAACGCCCGGCTAATTTTAGTGCCTTATTAATAGAGATAGGGTTTCACCCATGTTGGCCAGGTGTCTCAAACTCCTGACCTCAGGTGATCCACACTGCCATTTGGCGCTCCTCAAAGTGCTGGCCTACGGCATGAGCCACTGCACCTGGCCATCCGACTGCCTGTTTTTGGTACTCCAGCTTGGGCAAGCTAAGAATGTTTTCACATTTTTGTTGTCTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCTCAGGCTGGAGTGCAGTGGCAGCAATCTCAGCTCACTACAAGCTTCCGCCTCCCGGGTGTCATCGGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACCTACAGTTGCTGCTACCACGCCCAGCTAATTTTTTGTTATGATTTTGATCATCTGATATATTTAGCATTTATAGCCATCAGGTGCTGCTGCCTGGACCTTTTTTTCCCCTAGAAGTTTCGTTCTTGTTGCCCAGGCCACGACTCTTGACTTATGCAACCTCTGCGCTCCCGGGGTTCAAGCGATTCTCTTGCCTCAGCCCCCCGAGTAGCTGGGATTATCAGGTGTCCACCCATCACTGGCCCGGCCTAATTCTTAGTCGCTGTTCTAAAGAGATGAGGTTTTCCATGTTGAGCCAGGTTGGTCTCAGAACTCCTGACTCAGGTGATCCACCTGCCTTTGGCCTCCCAAAGTGCTGGCCAGGATGAGCCAGCTGCACCTGGCCACCACTGCCTGTTTCTGTACCGCTTGGCAAGCCTAAGAGATGGTTTTTCACATTTTTGTTTCTTTTTTTTTGGAGTACGGAGTCTCACCATCTGTCACCCAGGCTGGATTGCAGTGGCACAATCTCAGGCTCACTACAACGCTCCGCCTCCCGGGTTACACAGCTCATTCTCCTGCCTCCAGCCTCCCCGAGTAGCTGGGACTAACAGTTGCCTGCCACCACGCCCAGCTAATTTTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGCTCGCCTGACTTTTTTTCCCCCTAGCCACAGTTTGCTCTTGTTGCCCAGGCACGACCTTACTCACTGCCAACCTCTGGCCTCGCCGGGTTCAAGCGAGTTCTCTTGACCTCAGCCCCCCGAGTAGCTGGGATTACAGGTGTCCACCATCAGCGCCCGGCTAATTTTAGTGCTTTTAATAAGAGATGGGTTTCACCATTTGGCCAGGTGGTCTCAAACTCCTGGACCTCAGGTGATCCACCTGCCTTGGCCTCCCAAAGTGCTGGGCCAGGCATGAGCCACTGAACCTGGCCACCACTTGCCTGTTTTTGTACCGCTTGGCAAGCCTAAGAATGGATTTTCACATTTTTGTTTCTTTGTTTTTTGAGAGACGGAGTCTCCACTCCTGTCAACCCAGGCTGGAGATGCAGTGGCACAATCTCACGCTCACTACAAGCTCCGCCTCCCGGGTTACGCCATTCTCACTGCCTCAGTCCTTCCCGAGTGAGCTCGGGCTACAGTTGCCTTGCCACCACGCCCAGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACTGTGGTATGGATTCTTCCTGAACTCGTTGATCCGCCTGCCTCGGCCTCCCAAAAGGTGCTGGGATTACAGGCATGAGCCACCGTGACCGGCCACTGCTGCCGTGTTTTTGTACTGCTTGGCATAGCTAAGAATGGTTTTCATCACATTGTGAATAGTTTTGAAGAAAAATTTTTCAAGAATACATTTTGTGGCACACGAAAATTATATAGAAATTCAAAGTTTTCAATGTCACAAATAAGAGGTTTTATATTGGAACATAGCATGCTCACTCATTTAGGTATTGTTACGGCTTGCTTCCACACTACAAGCAGCCAGGGTTCAGAGGTCATGGCAGAGACCAACGTGGCCCACAAAGTGTGAATGTCACTTCCCTTTGTACAAGCTGTTTGCCCTAAAACTCTTGGCTAAGCAGAGTGAGTCATGAGAGAAGAGAGAAGGTGCATGGACTGAGGTCTGTCAAGGGCCTGTCAAGAGCCAGTAACCGTTGCTGTGCGCTCAAGGATGCCAAGATGAGTGGCTTTGCTCCATGAGCAACAAAGCCCAGGGGCCCAGCAAGCCAAGGCTGCTTGCCTCTTTGTCCCCTGGGGCCAGCTGTGCATCTTGTGGATGGGCTGAGAGTTGAGCAACCCATAACAGGCCTCCTGACCCACTGTGAGATGGTGGCATGTGAAAGGACCAGCATCCAACAGTCTTGCCTCTTACTATATTAGTTAATTTCCTGGGGCTACAGGAGCTTATTTACTCAAACTGAGTGACTAAAACAATGGAATGGATTTTCTCTCGCAGTTCTAAGAGGGTATTATTCTTTCAACAATCAAGGTGACAGCACGGCCATGCTCCCGAAAGACAGCTCTAGGAAAAGCTCCTGGTTTCTAGCGGCTGCCTGCACTTCCTTGGCATTCCTTGAGCTTCAGCTGCATCATTCAGTGCTTGCTTCGGTACCACCGTGCCTTCATCCCTGGGTCGCTTCCATCGTCTCTATGTCCAAATGTTCGCATCTTTTATAAGGATGCTTAGTCATTGGATCCCAGGGCCCATCCCTAATCTGGTATGACTTCATAATTAATGTGAGTTGCATTGAAAAGACGCTGTTATCCAAATAAAGCCATCTCACACGTATGGGGACTAGGACGTTCAGACATATCTTTTTGCGGGACAAAATTCTACTCCACTATACTTCCCACACACATGCAGCATTTCCACGTGGTGAATCTAAGAGTATTTAGGGTTCTTGCGATAAAAGGGATATGGCCCGGTTGACTATCCTGGGGATAAGAAATCAAAAGAGAAAAAAACTCTAGTATTGGTGTTAAGACCCTGCAGTTTTACATTCATTTCCTGCACCACTCCCTGCTGCCTGCAAGGCAGGCCAGCTGCTTCACCTAGGGGCAGAATTCGGAGAAAGAATACGTCTCTCTGGATGTAACTACTGCGACTCAGGCAACCCACTAGTGGAGCTTCACAGGTGGTTCATCTGCCAAAGATTCTGAGGTTTTTAGCCGTGAGATGATAGGGTCAGAAACCGGGTGGTGCTCATGGGGGAAAGCAGCTACTGGAAGAGTCTAGATGCTGCTTCCCCTCAGGACTGTGATTGACCTTCAACTGGCCCCTCATCCCCAAGAACCTCAGCTTCTTCCTCT * AS:i:827 NM:i:51 SA:Z:chr21,35346115,+,33M1I35M1D13M1D4M1I16M1D15M1I14M1I12M1D3M1D39M1D25M1I33M1I10M1I9M1I78M1I66M1I9M1D7M1I37M2I28M1I12M1I6M1I34M1I6M1I17M2I21M1I20M1I29M1I5M1I5M1I12M2I52M1I5M1I7M1I8M1I63M1D8M1I12M1I4M1I59M1D11M1I9M1I8M1D4M2I7M1D16M1D55M1D10M1I4M1I17M1I53M1I17M1I124M1I96M1I3M1I14M1I5M1I2M1I8M2I3M1I2M1I23M1I21M1I123M1I3M1I5M1D7M1I7M1I59M1I84M1I39M1I20M1I28M1I15M1I4M1I12M1I26M1D44M1I3M1I47M1I37M1I3M1D64M1I5M1D65M1I29M1I59M1I3M1I34M1D18M1D15M1D17M1I5M1I52M1D3M1I22M1I56M1I5M1I12M1D23M1I15M1I5M1I53M2I19M1D20M1I15M1I4M1D24M1I12M1I21M1I95M2I30M1I4M1D21M1I6M1I23M1I12M1I41M1I7M1I20M2I11M1D19M1I8M1I16M1D18M2I7M1D19M1I13M1I19M1I7M1I33M1I35M1I10M1I8M1I3M1I16M2I8M1I13M1I29M1I11M1I14M1I17M1I37M1I24M1D38M1I7M1I6M2I95M1D52M1I14M1I16M1I19M1I1M1D35M1I2M1D23M1I1M1I12M1I17M1I3M1I77M1I18M1I3M1I2M1I2M1I9M1I9M1I2M1I10M1I13M1I6M1I2M1I21M1I52M1D2M1I28M1I10M2I28M1I5M1I8M1I15M1I22M1D7M1I19M1I43M1D7M1D9M1I5M1D4M1D12M1I1M1I26M1I4M1I7M1I7M1D21M1I7M1I5M1D5M1I12M1I27M2I32M1I17M1I21M1I13M1D15M1I81M1I19M1D2M1I14M1I8M1I15M1I4M1I38M1I23M1I9M1I12M1I7M1D10M1I6M1I14M1I8M1I28M1I13M1I26M1I35M1I9M1D17M1I8M1I6M1D7M1D6M1I5M1I2M1I38M1I11M1D21M1I25M1D10M2I17M1D15M1I3M1I42M1I17M1D79M1I2M1I17M1I26M1I30M2I52M1I4M1I1M1D16M1I6M1I18M1D19M2I11M1I25M1I19M1D3M1I2M1I16M1I10M1D4M2I15M1I2M1D4M1I37M1I13M2I25M1D32M1D4M1I8M1I13M1I2M1I6M1I1M1D74M1I8M1I14M1I28M1I27M1I37M1D19M1I14M1I5M1I20M1I13M1D4M1D15M1I5M1D27M1D7M1I1M1I23M1I33M1I26M1I44M1D14M1I6M1D12M1I39M1I8M1I5M1I6M1I16M1I15M1I3M1I11M1I22M1D1M1D8M1D110M1I12M1I1M1I4M1I4M1I28M2I15M3405S,60,354;chr21,35351847,+,7658S4M1D43M1I22M2I7M1D25M1D8M1I8M1I5M1I14M1I8M1I43M1I27M1I18M1D9M1D15M1I40M1I33M1I26M1I10M1I29M1I12M1I4M1I5M1I13M1I18M1I28M1D11M1I9M1I2M1I8M1I4M1I3M1D11M1I63M1I2M1I11M1I23M1I3M1I46M1I20M1I18M1I6M1I6M2I6M1I18M1D26M1I7M1I3M1I9M1D9M1I1M1I8M2I39M1I14M1I5M1I27M1I15M1I8M1I24M1I2M2I12M1I29M1I57M1I17M1I2M1I2M1I54M1I2M2I30M1I6M1I21M1I58M1I13M1I23M1I8M1D13M1D11M1D6M2I15M1I20M1D30M1I47M1I16M1I4M1D13M1D4M1I2M1D9M1D4M1I28M1I17M1I4M1I4M1D11M1I13M2I9M1I22M1I10M1I9M1D12M1I16M1D22M1I4M1I30M1I10M1I14M1I4M1I7M1D17M1I17M1I13M1I5M1D10M1I22M1D25M1I8M1I10M1I20M1I18M1I15M1I21M1I15M1I15M1I13M1I7M1I28M1I10M1I5M1I5M1D26M1I6M1D18M1I8M1I6M1I14M1I33M,40,155;chr21,35351854,+,6495S38M1I24M1D44M1I1M1I16M2I16M1I16M1I7M1D18M1I20M1I3M1I11M1I8M1I14M1D1M1D30M1I5M2I5M1I4M1I13M1I1M1I24M1I2M1I13M1I4M2I1M1I4M1I14M1D17M1I37M1I20M1I21M1I14M1I3M1I1M1I36M1I9M1D28M2828S,40,41;
read1 2048 chr21 35351854 40 6495S38M1I24M1D44M1I1M1I16M2I16M1I16M1I7M1D18M1I20M1I3M1I11M1I8M1I14M1D1M1D30M1I5M2I5M1I4M1I13M1I1M1I24M1I2M1I13M1I4M2I1M1I4M1I14M1D17M1I37M1I20M1I21M1I14M1I3M1I1M1I36M1I9M1D28M2828S * 0 0 TCCTTGCCTTTCAGGTGCTTTAAGAGGGCTTATCGTTCTTTGACTCCCCTAGTAACTCAAAAGGGTGGCAAGATGCAACTCTGAGGCTTTCCAAGCTCTCTGCAAGCCTGCCTTCAGTAAGTCTGTGCACCACAAAGAAGCATAACTTATATCCTCTAGCTGAATTTACCTCCTGCTTCGAGCCCCTGTTTCCCATGTCATTTTAGGGGTCCAGATGTTTTTCCTGGAGGCATATACACACACACACTACACACACACAACACACACATCACACACACACACACACACACATATATACACACACACATTCCAGGGGCCTCTGAGGTGCCAAGACATGTGTGGGGTCCAATCTGGTTAACACTGATGTCCATGATCATTGAGTTCATTTTTTATATCAACTATGTGACACTTCCTGATAGTTTCCGTTCCTGTGTTAGAATTTGCAAAGTTGCCGACTATTTCTTTGAATGAAGAGTAGCTAGATCATGGGTCTACACCAGGTCATCAAGCAGCCGATTTCCCCTGTTGGAAGCTCCAAGCAAATTGTCAGCTCCAAGCATTGCCACACAGCTGTGGGTGTGCCACACTCCTTTTCCTTTTAATAAGATGATGATCTGCTAGTGTGTGAATGCTCTTGGAGTTTTATTTGTAGGTTTTTTCCTTGTATGTCGCAAATGTATCTATATTTCATCTTCCCTCTTGAGGGATATTTTCCATGGGTAGAGGATCTAGCGCTTTCTCTTTTGCGATTCCATGTGTGGCTTTAAAAAAAAGTCAGTTGACTGTTTATTTATGGCTTCTCTAAAGGTGATCTCTTTCTCCTAAGGACTGCTTTAAAAGCTTTCGCGTTCCCTCCCTCCCTTCCTCCCACCCCATCCCCCTTCTTCCTTTCCTTCCTCCCTCCCTCCTCCCTTCTGCTTCCTCCCTTTTCTCCCTGTCGTTTCCTCCTTTCTCCCATCCTCCCTCCTCCCTCTTTCCTTCTTTTTTCCCTTCCTCCCGCCCTCCTTCCTTCTTCCATCTTATATATTATAAATAATTTTCTTTCTTTCTTTATTTTTTTTTGAGATGGAGTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAACGGTGGTGATCTTGGCTTACTGCCAACCTCCACCTCCCTGGTTCAAGCGATTCACCTGCCTCAGCCTCCCTAGTAGCTGGGATTACAGGTGCCCGCCACCACACCCAGCTAATTTTTGTAATTGTAGTAGAGATGGGGTTTCACCATGGTGGGCCAGGCTGGTCTTGAACTCCTGAACTCAGGTAATCCACCCGCCTTGTCCTCCCAAAGTGCTGGAATTACAGGCATGAGCCACCACTCCCAGCCCTAATTAAAATATTTTCTTTCTGAGGCCCTTCCCTACCCTCTTGTACTTCTTTTGATACCGCCATCATAATGCATGTTAGGTGGACTCATCTGTGTACTCTATTACCCTCTCATCTGGTTTTTAATCTTTCTGTCTCCTTATACTGTAATCTCAGTGTTTCTTCTGCTTTAATTTTGGTATATGAATTATTCAGCTGTGTTCAAAGTGTGGTTCAAATGCGACTATATGCTTCTTTAAGTTTTTAGTTATTGTACTTCTCACCTCTAGAAGTTCTTCTGTGACACTTCTTATAGTTTCGCAGTTCTTGGGTAGAATTTGCAAACTTGTTGACTATTTCTTTGAAAAGAGTAGCTAGAATTGTTTTAGTCTGTGTATAGTGAGTATGAATATCTGAAACCTCTGTGAGTCTGTTTCTTTTGTCTCGCTAGCCCTACTCATGGCGTCCATGTTTTCCTGGATGTTTAGTTGGTTGTTCTTTGAATATGTCCAAACTCCCAGTTATTTCTGGGGAATACCCAAAGGCACACCTGTTCCTATCACCCAGTGAACTGCCATGTGTTTGTCTCCTGTCATGGTAGACATTTTGCATTCAGGGAGAGGCCTCTGCTCTCTGCAGAACAGTGTGAAATGCACCTCATTTTTGCCTTCAATGAAGGTTGTCTCTTGCTTGGCACCACCACTTCCTCAAATGACTAATGCCACTCTTGCTCACAGTGCTAAGGCGCTAAGGAGTTTATCAGAGGCTAGAGTGATTCTGCATCCTCTGGGGTTCTCAGGAAGCGAGGCCACAGGGCCATCTGTGCATGTAGTGACAGTGGGGTGGGGTGGATGAGCAGTTGGCAGTGGTGGGCACCTATGCTGCTGGCGCCACAGCTTTTTATATCTTGGTGAAAACAGACGCCCTTGCGTTTTCACTTGTAGATTCTCCGGCTACATCCACAAGAACAAATTCTGTCACAGAGGCCAGATAGACTATCAGTGTAATGGGCCCTTTCCCCTTTGATGATAGCAGCTTTTTTCGGGGGAGCAGGGGTTGCCAAACTTCTACGCCTTATTTTATCTTCCTTTCTGAGTTCTCCCCAGAGGCTGCTGGGTCCACCTCTCCCTCTGCCAGACAGACAGGCTCAGGACATAGCAAGAACGGAAGGGGTGTGGGGGTTGGTGGGAGGTATTAAGTTGGGGAAACGACAGCTCTTGTCTTTGTAGATTACCAGAACTGACACACGTACACACACGTACACTCACGCTCACTCACTCACTCATCTATCATCTATTTTTGGCCTAAGCTGCCTTTGGACACTTCCTTCGAAAAGCACATGAACTCTTCGGAGTTCTCCTGTTCCACCTTGGTAAATTTCCTATAGCCAACGCACTGAAAGTCCCTGCTGCCCTCCTTCCTCTGAGCTTGTGGGGCCCACAGATCCCCTGCTCCATTTCCTGCTTCATTTCAGCTGATGGTGAGCTTCCAGGGCAGGCTTGTAGGAAGGGCGGGCTAAGGCTGGGGAACTGCAGCACCCACCACCACCCGCCCGCCCCAGTGCTTGTTGCCCCTAGCCTCTGTCTCTCCTCGCTGTGCCCTTCCCTTAAGCCCCACTCTTGGCCTCCCACAAAGACAAGAGTTTGTTCTGTTTTTATATTGATAGGATGAACTCCCTCGTTCTAATACCTATCTGAATAGCCTGAGCAATTACATTTACAACCTCATGAAAAATACACAGCACTTGTCACGATGAATGATGTTTACCGTGAATAATTGCAGTTTTGAGTTCAAACATCCTTCTATAGTCCAAGAATGAGTAAATATCCCTATTCCCTACCCCTCCCCATTGCATTTGGGTTTGACATGACATGCAATCATTGTGAGTTTTACTGCCTGGGGTAGAATTGTTTTTGCCTGTATTGCCATTGCCAATTGACTGGAAGGACAAAAAAAGGAAACTTACCAATTGAGCAGTTTCTAGATGAACTTAAATATCTCAGAAATCTTGAAGCAATGAATGAACTATAACTTTCTGAAGTTGCAAAAATGATTCAAGTCGGAAGTGACCCATGGGAGCAACCTGGTCCTTAATTAGGACTGGAAAGAAAACGGTAGGCCCATGCGAGGTGGAACAGTGGCTTCCCCAAGGTCACACTGCAAGTGAGTGGTGGCACTAGTCACCCAGGAGTCCTCCTGACTCCATGGTATCCTGACCCCAGACCAGAGCCTTATTTGTGGTTAAAGAACGTGGAAAAACAGCTTATGTTTGAATTTTAGAAATCATGCCAGTAGCTAAAGATCTGCATTCTCATGAATATTGAGCTTTGCGTTGTGCGGGTTGCTACGAATTTTGTAACTATTTTCTCCTAGAGCTCTCAGTATTTTACATATGACCAATTCCATTCTATTATTGTCCCGGGAAAAGAGTGTGCATTTACTGAGCAGTAAGAGGGTGATTTGAAGTCCCTGGGGTCCCCCACCCTTGTCTTTCTATGTGAGATTGTATGTGCAGGGCTCACATTTATGTCTCCTCCAGGCAGCTCATGTGCACAGACTAGTTGTATTTATTAGAGCACCTACTGTGGTGCCATGGAAGCTATGTGGTAAGCTAAGCAGGACAAAAACTCCTGCTCTCACAAGAAGAAAGAATAAACAAGCAGACAATTGCCCGTATAATGTCAGCCTGGTGTGATGGCTCATCTCCTGGAATACCCTAGCACTTTGGGAGGTGACGATGGGAGGGATTGGCTTTAACTTCGGGAGTTCAAGATAAAGCCTGGGCAACCAAGACCCTTCTCTACAAAAAAAATCAAAAAATTAGACTGGGGGTCATGGCATGAGTCTCTGGCCCCTCGGGACCAGAGGCTCGGGAGCTGAGGCGTGGTTTTCACTGAGCCTGGGAGCGTTTGAGGCTGCAGTGAGCTGTGATCACAACCACCTGCACTGCCAGCCTGGCCACAGAGCGAGACCCTGTCCTCTAAATTAAACAACAACCCTAATGTCAAGATTAGGAAGTGTGGCAAAAAGGAACAAACAGTCAGGGTGACTGCCATTCTAGAAAGGGTGGTCGAGGGAAGGTCTCCTTGAAGCAGATCCTGTGGGAGTGGAGAGGGTAAGTCACGGACTCTCTGGAGGAACGAAGATTCCAGGTGGAAATGCCTTAGTGGGTGTTAAACGCTTTAACGGGTGTTAGCCAGAAAGCCAGAATGGCTGGAGCTGAAGGGAGTAGAGGAGGCGGCTAGGAAAATGAGGTCAGAAGATGGAGAGCAGGGCCGGATCACGAGAGCGGGCACAGAGAACGAGGAGGGAATTGGATTTTTGGAAATAGATTGTGGCAAAATACAAAATATTAAAATACATAAAATAAAATATGAAACCATAAATGTACTACCCTTTACCCATTTTAAGTATGCCAGTTCAGTTAGTGTTAAATACATTTACATCATTGTTACAACCCGTCTCCAGGAACTCTCTGCATCTTGCAAAATTAACAACTCTATGCCATTTCAACAGTTCGCATTTCCTCTCTCCCTCTCGTCATGGCAACCGCCATTGTTTCTTTCTTGTCTCGTAAATGTAGTACTTTGGGTGTAATCTCATCTAAGTGGAATCACACAGTGTGTGTCCTTTTAGTGACAGACTTTTTCACTTTGCATAATGTCCTGTAATATTCATCCATGTTGTAGCATGGTCAGATTTTATCCTTCCTTCTTAACATTTGTAATATTCCATTGTTACGGCATAGACTACATTTAGCTTATCTGTTCACCTGTGGATGGACAACTTGGGTTGCTATAGTAATAATATTGCTGTAAATATGGGTATACGATTATCTCTTTGTGACCCTGCTTTTAATTGTTTTGGATATATACCCAGAATATGGGAATTACTGAATCATGTTGGAGATTCTGTTTTTGATTTATTTATTTTATTTTTAATTTTTGAGATGGAGTCTCGTTTTCTGTCACCCAGGCTGGAGTGCAGTGACACGATCTCTGCTCACTGCAACCTCCTGCTCCCTTGCACCATTAATTCCTCAAAGATGCAGGCCTGGATCCAACGCCTTTGGGGACGGGTACTCCTGCCCACAGGAAAGAGGTTGAGGAGACAATAATGTCAACGAGAATCATCATCTTTGCTGTGGAAAATGGTGTGCAGAGTATTCTGGTGCCTCTGCCAAGTGATTGTCGCATGCTAGCCTTCCCTAGTAGCTGGGATTACAGGCATTTGCCACCAAGCCCCGGCTAATTTTGATGTATTTTTAGTAGAGACGGGGTTTATCATGTTGGCCAGGCTGGTCTCAAACTCCTGCCTCAAGGTGATCGCACCTGCCTCAGCACTCCCCAAATGGCTGGGATTATAGGTGTGAGCCATGCACCTGGCCTGATTGGTTATTTAAATTCTGAGAGGGGGTATACTAATGTGTTGAAAACACACAGGGATGGGATCAGGTATAGGTGGGGAGGGAGAGCAAAAGTTGGTATTTAGAATATGTTACGTTTGAACAAACCTAATACACATTCCACATCCAAGTGGACATAGAGGAGTTATTTGAAGCTCAGCAAGACACCTGAGTTGGGAGATCAGGAATTTGTGGATCATCTGGATATATTTAGCATTATGCCACAGGGCTGCTGCCCTGATTTTTTTCCCCCTAGACAGTTTCGCTCTGTTGCCTCTAGGCACGACCTTGACTCACTGCAGACCTCTGCCTCCCGGGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAGCTGGGATTAACAGGTGTCCACCATCACGCCCGGCTAATTTTAGTGCTTTTAATGAGATGGGTTTCACACATGTTGCCAGGTTGGTCTTCAAACTCCTGACCTCAGGTGATCCACCTGCCTTGGCCTCCCCAAAGTGGCTGGACCAGGCGATGAGCCACTGCACCTCGGCCACCACTGCCTGCTTTATTGTACCGCTTCGGCAAGCTAAGAATGGTTTTCAATTTTGTTTTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCCAGGCTGGAGTGCAGTGGCACAATCTCAGCTCACTACAAGCTCCGCCTCCCGGGTTCACGCCATTCTCCTGCCTCAAGCCTCCCGAGTCACGCTGCGGACGTACAGTTGCCTGCCACCACGCCCAGCTATTATATTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGGCTGCCTGACTTTTTTTCCCCCTAACAGTTTCGCTCTTGTTGCCCAGGCACGACCTTGACTCACTGCACATCCTCTGCCTCCCGGGTGTTCAAGCGATTCTCTTGCCCTCAGCCCCCCGAGTAAGCTGGGTTACAGGTGTCCACCATCAACGCCCGGCTAATTTTAGTGCCTTATTAATAGAGATAGGGTTTCACCCATGTTGGCCAGGTGTCTCAAACTCCTGACCTCAGGTGATCCACACTGCCATTTGGCGCTCCTCAAAGTGCTGGCCTACGGCATGAGCCACTGCACCTGGCCATCCGACTGCCTGTTTTTGGTACTCCAGCTTGGGCAAGCTAAGAATGTTTTCACATTTTTGTTGTCTTTTTTTTTTGGAGACGGAGTCTCACTCTGTCACCTCAGGCTGGAGTGCAGTGGCAGCAATCTCAGCTCACTACAAGCTTCCGCCTCCCGGGTGTCATCGGCCATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGACCTACAGTTGCTGCTACCACGCCCAGCTAATTTTTTGTTATGATTTTGATCATCTGATATATTTAGCATTTATAGCCATCAGGTGCTGCTGCCTGGACCTTTTTTTCCCCTAGAAGTTTCGTTCTTGTTGCCCAGGCCACGACTCTTGACTTATGCAACCTCTGCGCTCCCGGGGTTCAAGCGATTCTCTTGCCTCAGCCCCCCGAGTAGCTGGGATTATCAGGTGTCCACCCATCACTGGCCCGGCCTAATTCTTAGTCGCTGTTCTAAAGAGATGAGGTTTTCCATGTTGAGCCAGGTTGGTCTCAGAACTCCTGACTCAGGTGATCCACCTGCCTTTGGCCTCCCAAAGTGCTGGCCAGGATGAGCCAGCTGCACCTGGCCACCACTGCCTGTTTCTGTACCGCTTGGCAAGCCTAAGAGATGGTTTTTCACATTTTTGTTTCTTTTTTTTTGGAGTACGGAGTCTCACCATCTGTCACCCAGGCTGGATTGCAGTGGCACAATCTCAGGCTCACTACAACGCTCCGCCTCCCGGGTTACACAGCTCATTCTCCTGCCTCCAGCCTCCCCGAGTAGCTGGGACTAACAGTTGCCTGCCACCACGCCCAGCTAATTTTTTGTATTTTTGATCATCTGATATATTTAGCATTTATAGCCACAGGGCTGCTCGCCTGACTTTTTTTCCCCCTAGCCACAGTTTGCTCTTGTTGCCCAGGCACGACCTTACTCACTGCCAACCTCTGGCCTCGCCGGGTTCAAGCGAGTTCTCTTGACCTCAGCCCCCCGAGTAGCTGGGATTACAGGTGTCCACCATCAGCGCCCGGCTAATTTTAGTGCTTTTAATAAGAGATGGGTTTCACCATTTGGCCAGGTGGTCTCAAACTCCTGGACCTCAGGTGATCCACCTGCCTTGGCCTCCCAAAGTGCTGGGCCAGGCATGAGCCACTGAACCTGGCCACCACTTGCCTGTTTTTGTACCGCTTGGCAAGCCTAAGAATGGATTTTCACATTTTTGTTTCTTTGTTTTTTGAGAGACGGAGTCTCCACTCCTGTCAACCCAGGCTGGAGATGCAGTGGCACAATCTCACGCTCACTACAAGCTCCGCCTCCCGGGTTACGCCATTCTCACTGCCTCAGTCCTTCCCGAGTGAGCTCGGGCTACAGTTGCCTTGCCACCACGCCCAGCTAATTTTTTGTATTTTTAGTAGAGACGGGGTTTCACTGTGGTATGGATTCTTCCTGAACTCGTTGATCCGCCTGCCTCGGCCTCCCAAAAGGTGCTGGGATTACAGGCATGAGCCACCGTGACCGGCCACTGCTGCCGTGTTTTTGTACTGCTTGGCATAGCTAAGAATGGTTTTCATCACATTGTGAATAGTTTTGAAGAAAAATTTTTCAAGAATACATTTTGTGGCACACGAAAATTATATAGAAATTCAAAGTTTTCAATGTCACAAATAAGAGGTTTTATATTGGAACATAGCATGCTCACTCATTTAGGTATTGTTACGGCTTGCTTCCACACTACAAGCAGCCAGGGTTCAGAGGTCATGGCAGAGACCAACGTGGCCCACAAAGTGTGAATGTCACTTCCCTTTGTACAAGCTGTTTGCCCTAAAACTCTTGGCTAAGCAGAGTGAGTCATGAGAGAAGAGAGAAGGTGCATGGACTGAGGTCTGTCAAGGGCCTGTCAAGAGCCAGTAACCGTTGCTGTGCGCTCAAGGATGCCAAGATGAGTGGCTTTGCTCCATGAGCAACAAAGCCCAGGGGCCCAGCAAGCCAAGGCTGCTTGCCTCTTTGTCCCCTGGGGCCAGCTGTGCATCTTGTGGATGGGCTGAGAGTTGAGCAACCCATAACAGGCCTCCTGACCCACTGTGAGATGGTGGCATGTGAAAGGACCAGCATCCAACAGTCTTGCCTCTTACTATATTAGTTAATTTCCTGGGGCTACAGGAGCTTATTTACTCAAACTGAGTGACTAAAACAATGGAATGGATTTTCTCTCGCAGTTCTAAGAGGGTATTATTCTTTCAACAATCAAGGTGACAGCACGGCCATGCTCCCGAAAGACAGCTCTAGGAAAAGCTCCTGGTTTCTAGCGGCTGCCTGCACTTCCTTGGCATTCCTTGAGCTTCAGCTGCATCATTCAGTGCTTGCTTCGGTACCACCGTGCCTTCATCCCTGGGTCGCTTCCATCGTCTCTATGTCCAAATGTTCGCATCTTTTATAAGGATGCTTAGTCATTGGATCCCAGGGCCCATCCCTAATCTGGTATGACTTCATAATTAATGTGAGTTGCATTGAAAAGACGCTGTTATCCAAATAAAGCCATCTCACACGTATGGGGACTAGGACGTTCAGACATATCTTTTTGCGGGACAAAATTCTACTCCACTATACTTCCCACACACATGCAGCATTTCCACGTGGTGAATCTAAGAGTATTTAGGGTTCTTGCGATAAAAGGGATATGGCCCGGTTGACTATCCTGGGGATAAGAAATCAAAAGAGAAAAAAACTCTAGTATTGGTGTTAAGACCCTGCAGTTTTACATTCATTTCCTGCACCACTCCCTGCTGCCTGCAAGGCAGGCCAGCTGCTTCACCTAGGGGCAGAATTCGGAGAAAGAATACGTCTCTCTGGATGTAACTACTGCGACTCAGGCAACCCACTAGTGGAGCTTCACAGGTGGTTCATCTGCCAAAGATTCTGAGGTTTTTAGCCGTGAGATGATAGGGTCAGAAACCGGGTGGTGCTCATGGGGGAAAGCAGCTACTGGAAGAGTCTAGATGCTGCTTCCCCTCAGGACTGTGATTGACCTTCAACTGGCCCCTCATCCCCAAGAACCTCAGCTTCTTCCTCT * AS:i:879 NM:i:41 SA:Z:chr21,35346115,+,33M1I35M1D13M1D4M1I16M1D15M1I14M1I12M1D3M1D39M1D25M1I33M1I10M1I9M1I78M1I66M1I9M1D7M1I37M2I28M1I12M1I6M1I34M1I6M1I17M2I21M1I20M1I29M1I5M1I5M1I12M2I52M1I5M1I7M1I8M1I63M1D8M1I12M1I4M1I59M1D11M1I9M1I8M1D4M2I7M1D16M1D55M1D10M1I4M1I17M1I53M1I17M1I124M1I96M1I3M1I14M1I5M1I2M1I8M2I3M1I2M1I23M1I21M1I123M1I3M1I5M1D7M1I7M1I59M1I84M1I39M1I20M1I28M1I15M1I4M1I12M1I26M1D44M1I3M1I47M1I37M1I3M1D64M1I5M1D65M1I29M1I59M1I3M1I34M1D18M1D15M1D17M1I5M1I52M1D3M1I22M1I56M1I5M1I12M1D23M1I15M1I5M1I53M2I19M1D20M1I15M1I4M1D24M1I12M1I21M1I95M2I30M1I4M1D21M1I6M1I23M1I12M1I41M1I7M1I20M2I11M1D19M1I8M1I16M1D18M2I7M1D19M1I13M1I19M1I7M1I33M1I35M1I10M1I8M1I3M1I16M2I8M1I13M1I29M1I11M1I14M1I17M1I37M1I24M1D38M1I7M1I6M2I95M1D52M1I14M1I16M1I19M1I1M1D35M1I2M1D23M1I1M1I12M1I17M1I3M1I77M1I18M1I3M1I2M1I2M1I9M1I9M1I2M1I10M1I13M1I6M1I2M1I21M1I52M1D2M1I28M1I10M2I28M1I5M1I8M1I15M1I22M1D7M1I19M1I43M1D7M1D9M1I5M1D4M1D12M1I1M1I26M1I4M1I7M1I7M1D21M1I7M1I5M1D5M1I12M1I27M2I32M1I17M1I21M1I13M1D15M1I81M1I19M1D2M1I14M1I8M1I15M1I4M1I38M1I23M1I9M1I12M1I7M1D10M1I6M1I14M1I8M1I28M1I13M1I26M1I35M1I9M1D17M1I8M1I6M1D7M1D6M1I5M1I2M1I38M1I11M1D21M1I25M1D10M2I17M1D15M1I3M1I42M1I17M1D79M1I2M1I17M1I26M1I30M2I52M1I4M1I1M1D16M1I6M1I18M1D19M2I11M1I25M1I19M1D3M1I2M1I16M1I10M1D4M2I15M1I2M1D4M1I37M1I13M2I25M1D32M1D4M1I8M1I13M1I2M1I6M1I1M1D74M1I8M1I14M1I28M1I27M1I37M1D19M1I14M1I5M1I20M1I13M1D4M1D15M1I5M1D27M1D7M1I1M1I23M1I33M1I26M1I44M1D14M1I6M1D12M1I39M1I8M1I5M1I6M1I16M1I15M1I3M1I11M1I22M1D1M1D8M1D110M1I12M1I1M1I4M1I4M1I28M2I15M3405S,60,354;chr21,35351847,+,7658S4M1D43M1I22M2I7M1D25M1D8M1I8M1I5M1I14M1I8M1I43M1I27M1I18M1D9M1D15M1I40M1I33M1I26M1I10M1I29M1I12M1I4M1I5M1I13M1I18M1I28M1D11M1I9M1I2M1I8M1I4M1I3M1D11M1I63M1I2M1I11M1I23M1I3M1I46M1I20M1I18M1I6M1I6M2I6M1I18M1D26M1I7M1I3M1I9M1D9M1I1M1I8M2I39M1I14M1I5M1I27M1I15M1I8M1I24M1I2M2I12M1I29M1I57M1I17M1I2M1I2M1I54M1I2M2I30M1I6M1I21M1I58M1I13M1I23M1I8M1D13M1D11M1D6M2I15M1I20M1D30M1I47M1I16M1I4M1D13M1D4M1I2M1D9M1D4M1I28M1I17M1I4M1I4M1D11M1I13M2I9M1I22M1I10M1I9M1D12M1I16M1D22M1I4M1I30M1I10M1I14M1I4M1I7M1D17M1I17M1I13M1I5M1D10M1I22M1D25M1I8M1I10M1I20M1I18M1I15M1I21M1I15M1I15M1I13M1I7M1I28M1I10M1I5M1I5M1D26M1I6M1D18M1I8M1I6M1I14M1I33M,40,155;chr21,35351847,+,7076S4M1D1M1D31M1I4M1I10M1I2M1I8M1D8M1D22M1I6M1I9M1D12M1I5M1I47M1I10M1I7M2I6M1I6M1I5M1I3M1I2M1I3M1D7M1I5M1D9M1I15M1I9M1D19M1I25M1D8M1I43M1I6M1I4M1I18M1D13M1I11M1I1M1I37M1I11M1I17M1I3M1I2M1I13M1I6M1I17M1I36M2242S,22,51;
svim-2.0.0/src/tests/test_Collect.py 0000664 0000000 0000000 00000033244 14063053413 0017423 0 ustar 00root root 0000000 0000000 import unittest
import pysam
import tempfile
from svim.SVIM_COLLECT import bam_iterator, analyze_alignment_file_querysorted, retrieve_other_alignments
from svim.SVIM_input_parsing import parse_arguments
from random import choice, triangular, uniform
class TestCollect(unittest.TestCase):
def generate_random_sequence(self, length):
sequence=""
for i in range(length):
sequence+=choice("ACGT")
return sequence
def generate_random_cigar_string(self, readlength):
"""Generate random cigar string for a read of a given length. Simulate small mismatches and indels but nothing larger than 10bp."""
softclip_left = round(triangular(0, readlength, min(1000, readlength * 0.5)))
non_clipped = readlength - softclip_left
softclip_right = round(triangular(0, non_clipped, min(1000, non_clipped * 0.5)))
non_clipped = readlength - softclip_left - softclip_right
sequence = ""
read_bases_consumed = 0
while read_bases_consumed < non_clipped:
#choose next operation
if len(sequence) == 0 or sequence[-1] == "I" or sequence[-1] == "D":
next_operation = "M"
next_length = round(triangular(1, non_clipped - read_bases_consumed, min(30, non_clipped - read_bases_consumed)))
read_bases_consumed += next_length
else:
next_operation = choice("ID")
if next_operation == "I":
next_length = round(triangular(1, min(10, non_clipped - read_bases_consumed), 1))
read_bases_consumed += next_length
else:
next_length = round(triangular(1, 10, 1))
sequence += str(next_length) + next_operation
return "{0}S{1}{2}S".format(softclip_left, sequence, softclip_right)
def generate_random_cigar_string_hardclipped(self, readlength):
"""Generate random cigar string for a read of a given length.
Simulate small mismatches and indels but nothing larger than 10bp. Simulate hard-clipping and return tuple (left-clipped, right-clipped, cigar)"""
hardclip_left = round(triangular(0, readlength, min(1000, readlength * 0.5)))
non_clipped = readlength - hardclip_left
hardclip_right = round(triangular(0, non_clipped, min(1000, non_clipped * 0.5)))
non_clipped = readlength - hardclip_left - hardclip_right
sequence = ""
read_bases_consumed = 0
while read_bases_consumed < non_clipped:
#choose next operation
if len(sequence) == 0 or sequence[-1] == "I" or sequence[-1] == "D":
next_operation = "M"
next_length = round(triangular(1, non_clipped - read_bases_consumed, min(30, non_clipped - read_bases_consumed)))
read_bases_consumed += next_length
else:
next_operation = choice("ID")
if next_operation == "I":
next_length = round(triangular(1, min(10, non_clipped - read_bases_consumed), 1))
read_bases_consumed += next_length
else:
next_length = round(triangular(1, 10, 1))
sequence += str(next_length) + next_operation
return (hardclip_left, hardclip_right, "{0}H{1}{2}H".format(hardclip_left, sequence, hardclip_right))
def generate_read(self, qname, flag):
rname = "chr1"
pos = int(uniform(1,249250620))
mapq = int(triangular(0, 60, 50))
length = int(triangular(100, 20000, 15000))
cigar = self.generate_random_cigar_string(length)
seq = self.generate_random_sequence(length)
read_info = (qname, flag, rname, pos, mapq, cigar, "*", 0, 0, seq, "*", "")
return read_info
def generate_split_read_with_sa_tags(self, qname, flag):
length = int(triangular(100, 20000, 15000))
seq = self.generate_random_sequence(length)
suppl_rname = "chr1"
suppl_pos = int(uniform(1,249250620))
suppl_mapq = int(triangular(0, 60, 50))
suppl_hardclipped_left, suppl_hardclipped_right, suppl_cigar = self.generate_random_cigar_string_hardclipped(length)
prim_rname = "chr1"
prim_pos = int(uniform(1,249250620))
prim_mapq = int(triangular(0, 60, 50))
prim_cigar = self.generate_random_cigar_string(length)
supplementary_read_info = ( qname,
flag + 2048,
suppl_rname,
suppl_pos,
suppl_mapq,
suppl_cigar,
"*",
0,
0,
seq[suppl_hardclipped_left:-suppl_hardclipped_right],
"*",
"SA:Z:{rname},{pos},{strand},{cigar},{mapq},{nm};".format(rname=prim_rname,
pos=prim_pos,
strand=("-" if flag & 16 else "+"),
cigar=prim_cigar,
mapq=prim_mapq,
nm=0))
primary_read_info = ( qname,
flag,
prim_rname,
prim_pos,
prim_mapq,
prim_cigar,
"*",
0,
0,
seq,
"*",
"SA:Z:{rname},{pos},{strand},{cigar},{mapq},{nm};".format(rname=suppl_rname,
pos=suppl_pos,
strand=("-" if flag & 16 else "+"),
cigar=suppl_cigar.replace("H", "S"),
mapq=suppl_mapq,
nm=0))
return (primary_read_info, supplementary_read_info)
def setUp(self):
self.bam_file = tempfile.NamedTemporaryFile()
header = """@HD VN:1.0 SO:queryname
@SQ SN:chr1 LN:249250621
@SQ SN:chr2 LN:243199373
@SQ SN:chr3 LN:198022430
@SQ SN:chr4 LN:191154276
@SQ SN:chr5 LN:180915260
@SQ SN:chr6 LN:171115067
@SQ SN:chr7 LN:159138663
@SQ SN:chr8 LN:146364022
@SQ SN:chr9 LN:141213431
@SQ SN:chr10 LN:135534747
@SQ SN:chr11 LN:135006516
@SQ SN:chr12 LN:133851895
@SQ SN:chr13 LN:115169878
@SQ SN:chr14 LN:107349540
@SQ SN:chr15 LN:102531392
@SQ SN:chr16 LN:90354753
@SQ SN:chr17 LN:81195210
@SQ SN:chr18 LN:78077248
@SQ SN:chr19 LN:59128983
@SQ SN:chr20 LN:63025520
@SQ SN:chr21 LN:48129895
@SQ SN:chr22 LN:51304566
@SQ SN:chrX LN:155270560
@SQ SN:chrY LN:59373566
@SQ SN:chr6_ssto_hap7 LN:4928567
@SQ SN:chr6_mcf_hap5 LN:4833398
@SQ SN:chr6_cox_hap2 LN:4795371
@SQ SN:chr6_mann_hap4 LN:4683263
@SQ SN:chr6_apd_hap1 LN:4622290
@SQ SN:chr6_qbl_hap6 LN:4611984
@SQ SN:chr6_dbb_hap3 LN:4610396
@SQ SN:chr17_ctg5_hap1 LN:1680828
@SQ SN:chr4_ctg9_hap1 LN:590426
@SQ SN:chr1_gl000192_random LN:547496
@SQ SN:chrUn_gl000225 LN:211173
@SQ SN:chr4_gl000194_random LN:191469
@SQ SN:chr4_gl000193_random LN:189789
@SQ SN:chr9_gl000200_random LN:187035
@SQ SN:chrUn_gl000222 LN:186861
@SQ SN:chrUn_gl000212 LN:186858
@SQ SN:chr7_gl000195_random LN:182896
@SQ SN:chrUn_gl000223 LN:180455
@SQ SN:chrUn_gl000224 LN:179693
@SQ SN:chrUn_gl000219 LN:179198
@SQ SN:chr17_gl000205_random LN:174588
@SQ SN:chrUn_gl000215 LN:172545
@SQ SN:chrUn_gl000216 LN:172294
@SQ SN:chrUn_gl000217 LN:172149
@SQ SN:chr9_gl000199_random LN:169874
@SQ SN:chrUn_gl000211 LN:166566
@SQ SN:chrUn_gl000213 LN:164239
@SQ SN:chrUn_gl000220 LN:161802
@SQ SN:chrUn_gl000218 LN:161147
@SQ SN:chr19_gl000209_random LN:159169
@SQ SN:chrUn_gl000221 LN:155397
@SQ SN:chrUn_gl000214 LN:137718
@SQ SN:chrUn_gl000228 LN:129120
@SQ SN:chrUn_gl000227 LN:128374
@SQ SN:chr1_gl000191_random LN:106433
@SQ SN:chr19_gl000208_random LN:92689
@SQ SN:chr9_gl000198_random LN:90085
@SQ SN:chr17_gl000204_random LN:81310
@SQ SN:chrUn_gl000233 LN:45941
@SQ SN:chrUn_gl000237 LN:45867
@SQ SN:chrUn_gl000230 LN:43691
@SQ SN:chrUn_gl000242 LN:43523
@SQ SN:chrUn_gl000243 LN:43341
@SQ SN:chrUn_gl000241 LN:42152
@SQ SN:chrUn_gl000236 LN:41934
@SQ SN:chrUn_gl000240 LN:41933
@SQ SN:chr17_gl000206_random LN:41001
@SQ SN:chrUn_gl000232 LN:40652
@SQ SN:chrUn_gl000234 LN:40531
@SQ SN:chr11_gl000202_random LN:40103
@SQ SN:chrUn_gl000238 LN:39939
@SQ SN:chrUn_gl000244 LN:39929
@SQ SN:chrUn_gl000248 LN:39786
@SQ SN:chr8_gl000196_random LN:38914
@SQ SN:chrUn_gl000249 LN:38502
@SQ SN:chrUn_gl000246 LN:38154
@SQ SN:chr17_gl000203_random LN:37498
@SQ SN:chr8_gl000197_random LN:37175
@SQ SN:chrUn_gl000245 LN:36651
@SQ SN:chrUn_gl000247 LN:36422
@SQ SN:chr9_gl000201_random LN:36148
@SQ SN:chrUn_gl000235 LN:34474
@SQ SN:chrUn_gl000239 LN:33824
@SQ SN:chr21_gl000210_random LN:27682
@SQ SN:chrUn_gl000231 LN:27386
@SQ SN:chrUn_gl000229 LN:19913
@SQ SN:chrM LN:16571
@SQ SN:chrUn_gl000226 LN:15008
@SQ SN:chr18_gl000207_random LN:4262
@PG ID:ngmlr PN:nextgenmap-lr VN:0.2.7 CL:ngmlr -t 10 -r hg19.fa -q reads.fa -o reads.ngmlr.hg19.bam"""
self.bam_file.write(header.encode('utf-8'))
self.read_infos = []
#10 reads with only primary alignment
for index in range(10):
read_info = self.generate_read("read{}".format(index+1), 0)
self.read_infos.append(read_info)
sam_entry = "\n" + "\t".join([str(el) for el in read_info])
self.bam_file.write(sam_entry.encode('utf-8'))
#10 reads with primary and supplementary alignment
for index in range(10, 20):
primary_read_info, supplementary_read_info = self.generate_split_read_with_sa_tags("read{}".format(index+1), 0)
#primary with SA tag
self.read_infos.append(primary_read_info)
sam_entry = "\n" + "\t".join([str(el) for el in primary_read_info])
self.bam_file.write(sam_entry.encode('utf-8'))
#supplementary
self.read_infos.append(supplementary_read_info)
sam_entry = "\n" + "\t".join([str(el) for el in supplementary_read_info])
self.bam_file.write(sam_entry.encode('utf-8'))
self.bam_file.seek(0)
self.alignment_file = pysam.AlignmentFile(self.bam_file.name, "rb")
def test_bam_iterator(self):
bam_it = bam_iterator(self.alignment_file)
num_primary_only = 0
num_primary_supplementary = 0
num_total = 0
for prim, suppl, sec in bam_it:
if len(prim) == 1 and len(suppl) == 0 and len(sec) == 0:
num_primary_only += 1
if len(prim) == 1 and len(suppl) == 1 and len(sec) == 0:
num_primary_supplementary += 1
num_total += 1
self.assertEqual(num_total, 20)
self.assertEqual(num_primary_only, 10)
self.assertEqual(num_primary_supplementary, 10)
def test_analyze_alignment_file_querysorted(self):
arguments = ['alignment', 'myworkdir', 'mybamfile', 'mygenome']
options = parse_arguments('1.2.0', arguments)
signatures, translocation_signatures_all_bnds = analyze_alignment_file_querysorted(self.alignment_file, options)
self.assertEqual(len([sig for sig in signatures if sig.signature == "cigar"]), 0)
def test_retrieve_supplementary_alignment_from_primary(self):
alignment_it = self.alignment_file.fetch(until_eof=True)
alignments = list(alignment_it)
for i in range(10,30,2):
primary = alignments[i]
supplementary = alignments[i+1]
retrieved_supplementary_alns = retrieve_other_alignments(primary, self.alignment_file)
self.assertEqual(len(retrieved_supplementary_alns), 1)
self.assertEqual(retrieved_supplementary_alns[0].cigarstring, supplementary.cigarstring.replace("H", "S"))
self.assertEqual(retrieved_supplementary_alns[0].reference_id, supplementary.reference_id)
self.assertEqual(retrieved_supplementary_alns[0].reference_start, supplementary.reference_start)
self.assertEqual(retrieved_supplementary_alns[0].reference_end, supplementary.reference_end)
self.assertEqual(retrieved_supplementary_alns[0].flag, supplementary.flag)
self.assertEqual(retrieved_supplementary_alns[0].mapping_quality, supplementary.mapping_quality)
self.assertEqual(retrieved_supplementary_alns[0].query_sequence[retrieved_supplementary_alns[0].query_alignment_start:retrieved_supplementary_alns[0].query_alignment_end], supplementary.query_sequence)
self.assertEqual(retrieved_supplementary_alns[0].query_name, supplementary.query_name)
def test_retrieve_primary_alignment_from_supplementary(self):
alignment_it = self.alignment_file.fetch(until_eof=True)
alignments = list(alignment_it)
for i in range(10,30,2):
primary = alignments[i]
supplementary = alignments[i+1]
retrieved_primary_alns = retrieve_other_alignments(supplementary, self.alignment_file)
self.assertEqual(len(retrieved_primary_alns), 0) svim-2.0.0/src/tests/test_SVCandidate.py 0000664 0000000 0000000 00000012416 14063053413 0020161 0 ustar 00root root 0000000 0000000 import unittest
import unittest.mock
from svim.SVCandidate import CandidateDeletion, CandidateInversion
from svim.SVSignature import SignatureDeletion
class DeletionCandidateTestCase(unittest.TestCase):
def setUp(self):
self.contig = "chr1"
self.start = 1000
self.end = 2000
self.members = [SignatureDeletion(self.contig, self.start, self.end, "cigar", "read1")]
self.score = 2
self.std_span = 10.2346
self.std_pos = 21.3453
self.deletion = CandidateDeletion(self.contig,
self.start,
self.end,
self.members,
self.score,
self.std_span,
self.std_pos)
self.distance = 1000
self.size = 1000
self.other_contig = 'chr9'
self.deletion2 = CandidateDeletion(self.contig,
self.end+self.distance,
self.end+self.distance+self.size,
self.members,
self.score,
self.std_span,
self.std_pos)
self.inversion = CandidateInversion(self.contig,
self.end+self.distance,
self.end+self.distance+self.size,
self.members,
self.score,
self.std_span,
self.std_pos)
self.deletion3 = CandidateDeletion(self.other_contig,
self.end+self.distance,
self.end+self.distance+self.size,
self.members,
self.score,
self.std_span,
self.std_pos)
def test_get_key(self):
self.assertEqual(self.deletion.get_key(), ("DEL", self.contig, self.end),
'incorrect key')
def test_get_source(self):
self.assertEqual(self.deletion.get_source(), (self.contig, self.start, self.end),
'incorrect source')
def test_get_std_span(self):
self.assertEqual(self.deletion.get_std_span(), round(self.std_span, 2))
self.assertEqual(self.deletion.get_std_span(3), round(self.std_span, 3))
def test_get_std_pos(self):
self.assertEqual(self.deletion.get_std_pos(), round(self.std_pos, 2))
self.assertEqual(self.deletion.get_std_pos(3), round(self.std_pos, 3))
def test_downstream_distance_to(self):
self.assertEqual(self.deletion.downstream_distance_to(self.deletion2), self.distance,
'incorrect distance')
self.assertEqual(self.deletion2.downstream_distance_to(self.deletion), 0,
'distance should be 0 for upstream variant')
self.assertEqual(self.deletion.downstream_distance_to(self.inversion), float('Inf'),
'distance should be Inf for other variant types')
self.assertEqual(self.deletion.downstream_distance_to(self.deletion3), float('Inf'),
'distance should be Inf for variant on other contig')
def test_get_vcf_entry(self):
vcf_string_normal = "\t".join(["chr1",
"1000",
"PLACEHOLDERFORID",
"N",
"",
"2",
"PASS",
"SVTYPE=DEL;END=2000;SVLEN=-1000;SUPPORT=1;STD_SPAN=10.23;STD_POS=21.35",
"GT:DP:AD",
"./.:.:.,."])
self.assertEqual(self.deletion.get_vcf_entry(), vcf_string_normal,
'incorrect VCF record')
ref_allele = "ACGTCGGATCGCAT"
alt_allele = "A"
reference = unittest.mock.Mock()
reference.fetch.side_effect = [ref_allele, alt_allele]
vcf_string_sequence_allele = "\t".join(["chr1",
"1000",
"PLACEHOLDERFORID",
"ACGTCGGATCGCAT",
"A",
"2",
"PASS",
"SVTYPE=DEL;END=2000;SVLEN=-1000;SUPPORT=1;STD_SPAN=10.23;STD_POS=21.35",
"GT:DP:AD",
"./.:.:.,."])
self.assertEqual(self.deletion.get_vcf_entry(sequence_alleles=True, reference=reference),
vcf_string_sequence_allele,
'incorrect VCF record with sequence alleles')
svim-2.0.0/src/tests/test_Signature.py 0000664 0000000 0000000 00000002712 14063053413 0017773 0 ustar 00root root 0000000 0000000 import unittest
from svim.SVSignature import SignatureDeletion,SignatureInsertion
class TestSVSignature(unittest.TestCase):
def test_accessors(self):
deletion = SignatureDeletion("chr1", 100, 300, "cigar", "read1")
self.assertEqual(deletion.get_source(), ("chr1", 100, 300))
self.assertEqual(deletion.get_key(), ("DEL", "chr1", 300))
def test_downstream_distance_to(self):
deletion1 = SignatureDeletion("chr1", 100, 300, "cigar", "read1")
deletion2 = SignatureDeletion("chr1", 450, 500, "cigar", "read2")
deletion3 = SignatureDeletion("chr1", 150, 200, "cigar", "read3")
deletion4 = SignatureDeletion("chr2", 350, 400, "cigar", "read3")
insertion = SignatureInsertion("chr1", 150, 200, "cigar", "read2", "ACGTAGTAGCTAGCTTTGCTAGCATTAGCGACTGCTTACGCAGCTCCCTA")
self.assertEqual(deletion1.downstream_distance_to(deletion2), 150)
self.assertEqual(deletion1.downstream_distance_to(deletion3), 0)
self.assertEqual(deletion1.downstream_distance_to(deletion4), float("Inf"))
self.assertEqual(deletion1.downstream_distance_to(insertion), float("Inf"))
def test_as_string(self):
deletion1 = SignatureDeletion("chr1", 100, 300, "cigar", "read1")
self.assertEqual(deletion1.as_string(), "chr1\t100\t300\tDEL;cigar\tread1")
self.assertEqual(deletion1.as_string(":"), "chr1:100:300:DEL;cigar:read1")
if __name__ == '__main__':
unittest.main()
svim-2.0.0/src/tests/test_clustering.py 0000664 0000000 0000000 00000005461 14063053413 0020215 0 ustar 00root root 0000000 0000000 import unittest
import tempfile
from random import uniform, choices
from svim.SVIM_clustering import form_partitions, partition_and_cluster
from svim.SVSignature import SignatureDeletion
from svim.SVIM_input_parsing import parse_arguments
class TestSVIMClustering(unittest.TestCase):
def setUp(self):
self.signatures = []
#group 0
for i in range(10):
center = 100000 + uniform(-100, 100)
half_span = 1000 + uniform(-100, 100)
new_sig = SignatureDeletion("chr1", center - half_span, center + half_span, "cigar", str(i))
self.signatures.append(new_sig)
#group 1
for i in range(10, 20):
center = 200000 + uniform(-100, 100)
half_span = 1000 + uniform(-100, 100)
new_sig = SignatureDeletion("chr1", center - half_span, center + half_span, "cigar", str(i))
self.signatures.append(new_sig)
#group 2
for i in range(20, 30):
center = 100000 + uniform(-100, 100)
half_span = 2000 + uniform(-100, 100)
new_sig = SignatureDeletion("chr1", center - half_span, center + half_span, "cigar", str(i))
self.signatures.append(new_sig)
self.temp_genome = tempfile.NamedTemporaryFile(mode="w")
self.temp_genome.write('>chr1\n')
self.temp_genome.write("".join(choices(["A", "C", "G", "T"], k=300000)))
self.options = parse_arguments('1.5.0', ['alignment', 'myworkdir', 'mybamfile', self.temp_genome.name])
def tearDown(self):
self.temp_genome.close()
def test_partitioning(self):
partitions = form_partitions(self.signatures, 100)
self.assertEqual(len(partitions), 2)
for partition in partitions:
groups_in_partition = set([int(member.read) // 10 for member in partition])
self.assertTrue(groups_in_partition in [set([0,2]), set([1])])
def test_partitioning_large_distance(self):
partitions = form_partitions(self.signatures, 100000)
self.assertEqual(len(partitions), 1)
groups_in_partition = set([int(member.read) // 10 for member in partitions[0]])
self.assertEqual(groups_in_partition, set([0,1,2]))
def test_clustering(self):
clusters = partition_and_cluster(self.signatures, options=self.options, type="deleted regions")
self.assertEqual(len(clusters), 3)
for cluster in clusters:
self.assertEqual(len(set([int(member.read) // 10 for member in cluster.members])), 1)
def test_scores(self):
clusters = partition_and_cluster(self.signatures, options=self.options, type="deleted regions")
for cluster in clusters:
self.assertGreaterEqual(cluster.score, 10)
self.assertLessEqual(cluster.score, 10 + 20/8)
if __name__ == '__main__':
unittest.main()
svim-2.0.0/src/tests/test_consensus.py 0000664 0000000 0000000 00000003560 14063053413 0020054 0 ustar 00root root 0000000 0000000 import unittest
from unittest.mock import Mock
from random import choices
from svim.SVIM_COMBINE import generate_insertion_consensus
from svim.SVSignature import SignatureInsertion, SignatureClusterUniLocal
class TestSVIMConsensus(unittest.TestCase):
def setUp(self):
self.nucleotides = ["A", "C", "G", "T"]
#Prepare reference
self.genome = "A"*100 + "C"*100
self.reference = Mock()
self.reference.fetch = lambda contig, start, end: self.genome[start:end]
def test_skipping(self):
insertion_signatures = []
for i in range(10):
insertion_signatures.append(SignatureInsertion("chr1", 100, 100100, "suppl", "read"+str(i), "".join(choices(self.nucleotides, k=100000))))
cluster_long = SignatureClusterUniLocal("chr1", 100, 100100, 10, 10, insertion_signatures, "INS", 0, 0)
status_code, _ = generate_insertion_consensus(cluster_long, self.reference, maximum_haplotype_length = 10000)
self.assertEqual(status_code, 1)
def test_simple(self):
#Prepare cluster
insertion_sequence = "".join(choices(self.nucleotides, k=100))
insertion_signatures = []
for i in range(10):
insertion_signatures.append(SignatureInsertion("chr1", 100, 200, "cigar", "read"+str(i), insertion_sequence))
cluster_simple = SignatureClusterUniLocal("chr1", 100, 200, 10, 10, insertion_signatures, "INS", 0, 0)
status_code, result = generate_insertion_consensus(cluster_simple, self.reference)
self.assertEqual(status_code, 0)
realigned_insertion_start, realigned_insertion_size, insertion_consensus = result
self.assertEqual(realigned_insertion_start, 100)
self.assertEqual(realigned_insertion_size, 100)
self.assertEqual(insertion_consensus, insertion_sequence)
if __name__ == '__main__':
unittest.main()
svim-2.0.0/src/tests/test_input_parsing.py 0000664 0000000 0000000 00000002315 14063053413 0020713 0 ustar 00root root 0000000 0000000 import unittest
import tempfile
from svim.SVIM_input_parsing import guess_file_type, parse_arguments
class TestInputParsing(unittest.TestCase):
def test_guess_file_type(self):
fasta_paths = ["/test/path/test.file.fa", "/test/path/test.file.fasta", "/test/path/test.file.FA"]
fastq_paths = ["/test/path/test.file.fq", "/test/path/test.file.FQ", "/test/path/test.file.fastq"]
for p in fasta_paths:
self.assertEqual(guess_file_type(p), "fasta")
zipped_path1 = p + ".gz"
zipped_path2 = p + ".gzip"
self.assertEqual(guess_file_type(zipped_path1), "fasta_gzip")
self.assertEqual(guess_file_type(zipped_path2), "fasta_gzip")
list_path = p + ".fn"
self.assertEqual(guess_file_type(list_path), "list")
for p in fastq_paths:
self.assertEqual(guess_file_type(p), "fastq")
zipped_path1 = p + ".gz"
zipped_path2 = p + ".gzip"
self.assertEqual(guess_file_type(zipped_path1), "fastq_gzip")
self.assertEqual(guess_file_type(zipped_path2), "fastq_gzip")
list_path = p + ".fn"
self.assertEqual(guess_file_type(list_path), "list")
svim-2.0.0/src/tests/test_inter.py 0000664 0000000 0000000 00000000707 14063053413 0017155 0 ustar 00root root 0000000 0000000 import unittest
from svim.SVIM_inter import is_similar
class TestSVIMInter(unittest.TestCase):
def test_is_similar(self):
self.assertFalse(is_similar("chrI", 0, 100, "chrII", 0, 100))
self.assertTrue(is_similar("chrI", 0, 100, "chrI", 0, 100))
self.assertTrue(is_similar("chrI", 0, 100, "chrI", 10, 90))
self.assertFalse(is_similar("chrI", 100, 105, "chrI", 21, 100))
if __name__ == '__main__':
unittest.main()
svim-2.0.0/src/tests/test_intra.py 0000664 0000000 0000000 00000001742 14063053413 0017151 0 ustar 00root root 0000000 0000000 import unittest
from svim.SVIM_intra import analyze_cigar_indel
class TestSVIMIntra(unittest.TestCase):
def test_analyze_cigar_indel(self):
tuples = [(5,10), (4,20), (0,10), (7,10), (8,5), (0,5), (1,50), (0,30), (4,25), (5,15)]
indels = [(30, 50, 50, "INS")]
self.assertEqual(analyze_cigar_indel(tuples, 30), indels)
tuples = [(5,10), (4,20), (0,30), (2,50), (0,30), (4,25), (5,15)]
indels = [(30, 50, 50, "DEL")]
self.assertEqual(analyze_cigar_indel(tuples, 30), indels)
tuples = [(5,10), (4,20), (0,30), (2,40), (1,50), (0,30), (4,25), (5,15)]
indels = [(30, 50, 40, "DEL"), (70, 50, 50, "INS")]
self.assertEqual(analyze_cigar_indel(tuples, 30), indels)
tuples = [(5,10), (4,20), (0,30), (1,40), (2,50), (0,30), (4,25), (5,15)]
indels = [(30, 50, 40, "INS"), (30, 90, 50, "DEL")]
self.assertEqual(analyze_cigar_indel(tuples, 30), indels)
if __name__ == '__main__':
unittest.main()
svim-2.0.0/src/tests/test_satag.py 0000664 0000000 0000000 00000003442 14063053413 0017132 0 ustar 00root root 0000000 0000000 import unittest
import pysam
import os
from svim.SVIM_COLLECT import retrieve_other_alignments
class TestSAExtraction(unittest.TestCase):
def setUp(self):
TESTDATA_FILENAME = os.path.join(os.path.dirname(__file__), 'chimeric_read.sam')
self.samfile = pysam.AlignmentFile(TESTDATA_FILENAME, "r")
self.alignments = list(self.samfile.fetch(until_eof=True))
def test_fetch(self):
self.assertEqual(len(self.alignments), 4)
def test_satag_length(self):
primary = self.alignments[0]
supplementary_alns = retrieve_other_alignments(primary, self.samfile)
self.assertEqual(len(supplementary_alns), 3)
def test_satag_extraction_complete(self):
primary = self.alignments[0]
supplementary_alns = retrieve_other_alignments(primary, self.samfile)
for index, aln in enumerate(supplementary_alns):
self.assertEqual(aln.cigarstring, self.alignments[index+1].cigarstring)
self.assertEqual(aln.reference_id, self.alignments[index+1].reference_id)
self.assertEqual(aln.reference_start, self.alignments[index+1].reference_start)
self.assertEqual(aln.reference_end, self.alignments[index+1].reference_end)
self.assertEqual(aln.flag, self.alignments[index+1].flag)
self.assertEqual(aln.mapping_quality, self.alignments[index+1].mapping_quality)
self.assertEqual(aln.query_sequence, self.alignments[index+1].query_sequence)
self.assertEqual(aln.query_name, self.alignments[index+1].query_name)
self.assertEqual(aln.query_alignment_start, self.alignments[index+1].query_alignment_start)
self.assertEqual(aln.query_alignment_end, self.alignments[index+1].query_alignment_end)
if __name__ == '__main__':
unittest.main()