def test_calc_coverage_4(self):
"""If uniqueley_aligned_only is True skip any mapping of read
that are aligned to more than on location.
"""
self.coverage_calculator = CoverageCalculator(
uniquely_aligned_only=True)
self._generate_bam_file(self.example_data.sam_content_3,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_3(self):
"""If read_count_splitting is set to False then every
mapping is counted as one to each of the matching position
independent how often its read is mapped in in total.
"""
self.coverage_calculator = CoverageCalculator(
read_count_splitting=False)
self._generate_bam_file(self.example_data.sam_content_2,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_5(self):
"""If first_base_only is True only the first nucleotide of a
mapping is considered.
"""
self.coverage_calculator = CoverageCalculator(
coverage_style="first_base_only")
self._generate_bam_file(self.example_data.sam_content_1,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
self.assertListEqual(
self.coverage_calculator._coverages["reverse"][0:15].tolist(),
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
-5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def _create_coverage_files_for_lib(self, lib_name, bam_path,
no_of_aligned_reads,
min_no_of_aligned_reads):
"""Perform the coverage calculation for a given library."""
if not self._args.non_strand_specific:
strands = ["forward", "reverse"]
else:
strands = ["forward_and_reverse"]
if self._all_coverage_file_exist(lib_name, strands,
no_of_aligned_reads,
min_no_of_aligned_reads):
return
read_count_splitting = True
if self._args.skip_read_count_splitting:
read_count_splitting = False
coverage_calculator = CoverageCalculator(
read_count_splitting=read_count_splitting,
uniquely_aligned_only=self._args.unique_only,
coverage_style=self._args.coverage_style,
clip_length=self._args.clip_length,
non_strand_specific=self._args.non_strand_specific,
)
(
coverage_writers_raw,
coverage_writers_tnoar_min_norm,
coverage_writers_tnoar_mil_norm,
) = self._wiggle_writers(lib_name, strands, no_of_aligned_reads,
min_no_of_aligned_reads)
for ref_seq, coverages in coverage_calculator.ref_seq_and_coverages(
bam_path):
for strand in strands:
coverage_writers_raw[strand].write_replicons_coverages(
ref_seq, coverages[strand])
coverage_writers_tnoar_min_norm[
strand].write_replicons_coverages(
ref_seq,
coverages[strand],
factor=min_no_of_aligned_reads / no_of_aligned_reads,
)
coverage_writers_tnoar_mil_norm[
strand].write_replicons_coverages(
ref_seq,
coverages[strand],
factor=1000000 / no_of_aligned_reads,
)
for strand in strands:
coverage_writers_raw[strand].close_file()
def _create_coverage_files_for_lib(
self, lib_name, bam_path, no_of_aligned_reads,
min_no_of_aligned_reads):
"""Perform the coverage calculation for a given library."""
if not self._args.non_strand_specific:
strands = ["forward", "reverse"]
else:
strands = ["forward_and_reverse"]
if self._all_coverage_file_exist(
lib_name, strands, no_of_aligned_reads,
min_no_of_aligned_reads):
return
read_count_splitting = True
if self._args.skip_read_count_splitting:
read_count_splitting = False
coverage_calculator = CoverageCalculator(
read_count_splitting=read_count_splitting,
uniquely_aligned_only=self._args.unique_only,
coverage_style=self._args.coverage_style,
clip_length=self._args.clip_length,
non_strand_specific=self._args.non_strand_specific)
(coverage_writers_raw, coverage_writers_tnoar_min_norm,
coverage_writers_tnoar_mil_norm) = self._wiggle_writers(
lib_name, strands, no_of_aligned_reads, min_no_of_aligned_reads)
for ref_seq, coverages in coverage_calculator.ref_seq_and_coverages(
bam_path):
for strand in strands:
coverage_writers_raw[strand].write_replicons_coverages(
ref_seq, coverages[strand])
coverage_writers_tnoar_min_norm[
strand].write_replicons_coverages(
ref_seq, coverages[strand],
factor=min_no_of_aligned_reads/no_of_aligned_reads)
coverage_writers_tnoar_mil_norm[
strand].write_replicons_coverages(
ref_seq, coverages[strand],
factor=1000000/no_of_aligned_reads)
for strand in strands:
coverage_writers_raw[strand].close_file()
def create_coverage_files_TK(
self, no_of_aligned_reads, min_no_of_aligned_reads):
if not self._args.non_strand_specific:
strands = ["forward", "reverse"]
else:
strands = ["forward_and_reverse"]
if self._args.skip_read_count_splitting:
read_count_splitting = False
else:
read_count_splitting = True
from reademptionlib.coveragecalculator import CoverageCalculator
coverage_calculator = CoverageCalculator(
read_count_splitting=read_count_splitting,
uniquely_aligned_only=self._args.unique_only,
coverage_style=self._args.coverage_style,
clip_length=self._args.clip_length,
non_strand_specific=self._args.non_strand_specific)
(coverage_writers_raw, coverage_writers_tnoar_min_norm,
coverage_writers_tnoar_mil_norm) = self._wiggle_writers(
strands, no_of_aligned_reads, min_no_of_aligned_reads)
for ref_seq, coverages in coverage_calculator.ref_seq_and_coverages(
self._args.input_coverage):
for strand in strands:
coverage_writers_raw[strand].write_replicons_coverages(
ref_seq, coverages[strand])
for strand in strands:
coverage_writers_tnoar_min_norm[
strand].write_replicons_coverages(
ref_seq, coverages[strand],
factor=min_no_of_aligned_reads/no_of_aligned_reads)
for strand in strands:
coverage_writers_tnoar_mil_norm[
strand].write_replicons_coverages(
ref_seq, coverages[strand],
factor=self._args.factor/no_of_aligned_reads)
for strand in strands:
coverage_writers_raw[strand].close_file()
def test_calc_coverage_4(self):
"""If uniqueley_aligned_only is True skip any mapping of read
that are aligned to more than on location.
"""
self.coverage_calculator = CoverageCalculator(
uniqueley_aligned_only=True)
self._generate_bam_file(
self.example_data.sam_content_3, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_3(self):
"""If read_count_splitting is set to False then every
mapping is counted as one to each of the matching position
independent how often its read is mapped in in total.
"""
self.coverage_calculator = CoverageCalculator(
read_count_splitting=False)
self._generate_bam_file(
self.example_data.sam_content_2, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_4():
"""If uniqueley_aligned_only is True skip any mapping of read
that are aligned to more than on location.
"""
coverage_calculator = CoverageCalculator(uniquely_aligned_only=True)
bam_file_4 = generate_bam_file(ccd.sam_content_3, ccd.sam_bam_prefix)
coverage_calculator._init_coverage_list(bam_file_4.lengths[0])
coverage_calculator._calc_coverage("chrom", bam_file_4)
assert (coverage_calculator._coverages["forward"][0:15]).all() == (
np.array([
3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 0.0, 0.0, 0.0,
0.0, 0.0
])).all()
def test_calc_coverage_5(self):
"""If first_base_only is True only the first nucleotide of a
mapping is considered.
"""
self.coverage_calculator = CoverageCalculator(first_base_only=True)
self._generate_bam_file(
self.example_data.sam_content_1, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0])
self.assertListEqual(
self.coverage_calculator._coverages[
"reverse"][0:15],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -5.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_3():
"""If read_count_splitting is set to False then every
mapping is counted as one to each of the matching position
independent how often its read is mapped in in total.
"""
coverage_calculator = CoverageCalculator(read_count_splitting=False)
bam_file_3 = generate_bam_file(ccd.sam_content_2, ccd.sam_bam_prefix)
coverage_calculator._init_coverage_list(bam_file_3.lengths[0])
coverage_calculator._calc_coverage("chrom", bam_file_3)
assert (coverage_calculator._coverages["forward"][0:15]).all() == (
np.array([
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0,
0.0, 0.0
])).all()
def data_coverage_calculator():
coverage_calculator = CoverageCalculator()
sam_bam_prefix = "dummy"
sam_content_1 = """@HD VN:1.0
@SQ SN:chrom LN:1500
@SQ SN:plasmid1 LN:100
@SQ SN:plasmid2 LN:200
myread:001 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:002 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:003 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:004 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:005 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:006 16 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:007 16 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:008 16 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:009 16 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:010 16 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
"""
sam_content_2 = """@HD VN:1.0
@SQ SN:chrom LN:1500
@SQ SN:plasmid1 LN:100
@SQ SN:plasmid2 LN:200
myread:001 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:2 XI:i:1 XA:Z:Q
"""
sam_content_3 = """@HD VN:1.0
@SQ SN:chrom LN:1500
@SQ SN:plasmid1 LN:100
@SQ SN:plasmid2 LN:200
myread:001 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:002 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:003 0 chrom 1 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:1 XI:i:1 XA:Z:Q
myread:004 0 chrom 5 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:9 XI:i:1 XA:Z:Q
myread:005 0 chrom 5 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:9 XI:i:1 XA:Z:Q
myread:006 0 chrom 5 255 10M * 0 0 GTGGACAACC * NM:i:1 MD:Z:11T3 NH:i:9 XI:i:1 XA:Z:Q
"""
global coverage_calculator
global sam_bam_prefix
global sam_content_1
global sam_content_2
global sam_content_3
def test_calc_coverage_5():
"""If first_base_only is True only the first nucleotide of a
mapping is considered.
"""
coverage_calculator = CoverageCalculator(coverage_style="first_base_only")
bam_file_5 = generate_bam_file(ccd.sam_content_1, ccd.sam_bam_prefix)
coverage_calculator._init_coverage_list(bam_file_5.lengths[0])
coverage_calculator._calc_coverage("chrom", bam_file_5)
assert (coverage_calculator._coverages["forward"][0:15]).all() == (
np.array([
5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0
])).all()
assert (coverage_calculator._coverages["reverse"][0:15]).all() == (
np.array([
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -5.0, 0.0, 0.0, 0.0,
0.0, 0.0
])).all()
class TestCoverageCalculator(unittest.TestCase):
def setUp(self):
self.coverage_calculator = CoverageCalculator()
self.example_data = ExampleData()
self._sam_bam_prefix = "dummy"
def tearDown(self):
for suffix in [".sam", ".bam", ".bam.bai"]:
if os.path.exists(self._sam_bam_prefix + suffix) is True:
os.remove(self._sam_bam_prefix + suffix)
def _generate_bam_file(self, sam_content, file_prefix):
sam_file = "%s.sam" % file_prefix
bam_file = "%s.bam" % file_prefix
sam_fh = open(sam_file, "w")
sam_fh.write(sam_content)
sam_fh.close()
pysam.view("-Sb", "-o%s" % bam_file, sam_file)
pysam.index(bam_file)
self._bam = pysam.Samfile(bam_file)
def test_init_coverage_list(self):
self.coverage_calculator._init_coverage_list(10)
self.assertListEqual(
sorted(self.coverage_calculator._coverages.keys()),
["forward", "reverse"])
self.assertListEqual(
self.coverage_calculator._coverages["forward"], [0.0] * 10)
self.assertListEqual(
self.coverage_calculator._coverages["reverse"], [0.0] * 10)
def test_calc_coverage_1(self):
"""Check correct start at first list element"""
self._generate_bam_file(
self.example_data.sam_content_1, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertEqual(
len(self.coverage_calculator._coverages["forward"]), 1500)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15],
[5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0,
0.0, 0.0, 0.0, 0.0, 0.0])
self.assertListEqual(
self.coverage_calculator._coverages["reverse"][0:15],
[-5.0, -5.0, -5.0, -5.0, -5.0, -5.0, -5.0, -5.0, -5.0, -5.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_2(self):
"""Consider how often a read is mapped. Mappings of reads that
are aligned to several location contribute only fractions to
the counting.
"""
self._generate_bam_file(
self.example_data.sam_content_2, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_3(self):
"""If read_count_splitting is set to False then every
mapping is counted as one to each of the matching position
independent how often its read is mapped in in total.
"""
self.coverage_calculator = CoverageCalculator(
read_count_splitting=False)
self._generate_bam_file(
self.example_data.sam_content_2, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_4(self):
"""If uniqueley_aligned_only is True skip any mapping of read
that are aligned to more than on location.
"""
self.coverage_calculator = CoverageCalculator(
uniqueley_aligned_only=True)
self._generate_bam_file(
self.example_data.sam_content_3, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def test_calc_coverage_5(self):
"""If first_base_only is True only the first nucleotide of a
mapping is considered.
"""
self.coverage_calculator = CoverageCalculator(first_base_only=True)
self._generate_bam_file(
self.example_data.sam_content_1, self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages[
"forward"][0:15],
[5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0])
self.assertListEqual(
self.coverage_calculator._coverages[
"reverse"][0:15],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -5.0,
0.0, 0.0, 0.0, 0.0, 0.0])
def setUp(self):
self.coverage_calculator = CoverageCalculator()
self.example_data = ExampleData()
self._sam_bam_prefix = "dummy"
class TestCoverageCalculator(unittest.TestCase):
def setUp(self):
self.coverage_calculator = CoverageCalculator()
self.example_data = ExampleData()
self._sam_bam_prefix = "dummy"
def tearDown(self):
for suffix in [".sam", ".bam", ".bam.bai"]:
if os.path.exists(self._sam_bam_prefix + suffix) is True:
os.remove(self._sam_bam_prefix + suffix)
def _generate_bam_file(self, sam_content, file_prefix):
sam_file = "{}.sam".format(file_prefix)
bam_file = "{}.bam".format(file_prefix)
sam_fh = open(sam_file, "w")
sam_fh.write(sam_content)
sam_fh.close()
pysam.view("-Sb",
"-o{}".format(bam_file),
sam_file,
catch_stdout=False)
pysam.index(bam_file)
self._bam = pysam.Samfile(bam_file)
def test_init_coverage_list(self):
self.coverage_calculator._init_coverage_list(10)
self.assertListEqual(
sorted(self.coverage_calculator._coverages.keys()),
["forward", "reverse"],
)
self.assertListEqual(
self.coverage_calculator._coverages["forward"].tolist(),
[0.0] * 10)
self.assertListEqual(
self.coverage_calculator._coverages["reverse"].tolist(),
[0.0] * 10)
def test_calc_coverage_1(self):
"""Check correct start at first list element"""
self._generate_bam_file(self.example_data.sam_content_1,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertEqual(len(self.coverage_calculator._coverages["forward"]),
1500)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
5.0,
5.0,
5.0,
5.0,
5.0,
5.0,
5.0,
5.0,
5.0,
5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
self.assertListEqual(
self.coverage_calculator._coverages["reverse"][0:15].tolist(),
[
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
-5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_2(self):
"""Consider how often a read is mapped. Mappings of reads that
are aligned to several location contribute only fractions to
the counting.
"""
self._generate_bam_file(self.example_data.sam_content_2,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
0.5,
0.5,
0.5,
0.5,
0.5,
0.5,
0.5,
0.5,
0.5,
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_3(self):
"""If read_count_splitting is set to False then every
mapping is counted as one to each of the matching position
independent how often its read is mapped in in total.
"""
self.coverage_calculator = CoverageCalculator(
read_count_splitting=False)
self._generate_bam_file(self.example_data.sam_content_2,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_4(self):
"""If uniqueley_aligned_only is True skip any mapping of read
that are aligned to more than on location.
"""
self.coverage_calculator = CoverageCalculator(
uniquely_aligned_only=True)
self._generate_bam_file(self.example_data.sam_content_3,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
3.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def test_calc_coverage_5(self):
"""If first_base_only is True only the first nucleotide of a
mapping is considered.
"""
self.coverage_calculator = CoverageCalculator(
coverage_style="first_base_only")
self._generate_bam_file(self.example_data.sam_content_1,
self._sam_bam_prefix)
self.coverage_calculator._init_coverage_list(self._bam.lengths[0])
self.coverage_calculator._calc_coverage("chrom", self._bam)
self.assertListEqual(
self.coverage_calculator._coverages["forward"][0:15].tolist(),
[
5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
self.assertListEqual(
self.coverage_calculator._coverages["reverse"][0:15].tolist(),
[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
-5.0,
0.0,
0.0,
0.0,
0.0,
0.0,
],
)
def setUp(self):
self.coverage_calculator = CoverageCalculator()
self.example_data = ExampleData()
self._sam_bam_prefix = "dummy"
