Skip to content
GitLab
Commit c9ab2fce authored by Motazedi's avatar Motazedi
Browse files

PopPoly method for diploid & polyploid haplotyping in F1 populations

parents
Expand all Hide whitespace changes
Inline Side-by-side
PopPoly_wrapped.pl 0 → 100755
View file @ c9ab2fce
#!/usr/bin/env perl
# A simple perl wrapper for PopPoly to be able to specify the contig name and maximum genotype missing rate
# for haplotyping.
# Useful when multiple contigs are present in the bam and VCF files, which causes error for haplotyping.
# This wrapper extracts the desired contig from the bam and VCF files, extracts SNPs and breaks down complex varinats
# in the VCF file, filters out SNPs based on their genotype missing rate and runs PopPoly with the passed input options.
# This script should be stored in the same folder as PopPoly main.py and break_vcf.sh.
# Written by Ehsan Motazedi, Wageningen University & Research, 20-07-2018.
# Last modified: 15-08-2018
use strict;
use warnings;
use File::Temp qw/ tempfile tempdir /;
use Cwd 'abs_path';
use Scalar::Util qw(looks_like_number);
sub signal_handler{
die "\nCaught a signal: $!\n";
}
my @PATH = split /\//, abs_path($0);
my $PopPoly_Path = join '/', @PATH[0..$#PATH-1];
my $hlp_msg = "\nA simple perl wrapper for PopPoly, so that the contig name and the maximum genotype missing rate\nof each SNP can be specified for haplotyping. Useful when multiple contigs are present in the BAM\nand VCF files, which are not handled directly by PopPoly. Also, useful to exclude SNPs from phasings\nbased upon their genotype missing rate in the VCF file.\n\nThis wrapper extracts the desired contig from the bam and VCF files, performs SNP filtering and runs PopPoly\nwith the passed input options. To run this script it should be stored in the same folder as PopPoly main.py.\n\nInput parameters:\n\n\tparameters passed to PopPoly (see ./main.py -h)\n\n\t-h, --help\tprint this help message and exit.\n\t-c, --contig\tname of the contig to be phased.\n\t--maxMISS\tmaximum tolerable genotype missing rate for each SNP to be included in phasing.\n\nWritten by Ehsan Motazedi, Wageningen University & Research, 20-07-2018.";
$SIG{INT} = \&signal_handler;
$SIG{TERM} = \&signal_handler;
my %options_set;
my @to_remove;
my @iftrue_opts = ("t","top","skip","filter","impute","redose");
my @toget_opts = ("c","contig","a", "aggressive", "e", "error", "r", "rho", "k", "kappa", "w", "warmup", "v", "verror", "P1", "P2", "mmq", "mbq", "maxIS", "maxMISS");
my $n=-1;
my ($fh1, $contig_bam) = tempfile(TEMPLATE => "tmp_bamXXXX", DIR=>"/tmp", SUFFIX => ".bam"); # tmp file to store contig reads if contig is specified
close($fh1);
my ($fh2, $contig_vcf) = tempfile(TEMPLATE => "tmp_vcfXXXX", DIR=>"/tmp", SUFFIX => ".vcf"); # tmp file to store contig variants if contig is specified
close($fh2);
my ($fh3, $contig_vcf_broken) = tempfile(TEMPLATE => "tmp_vcf_brokenXXXX", DIR=>"/tmp", SUFFIX => ".vcf"); # tmp file to store contig variants if contig is specified
close($fh3);
while ($n < $#ARGV){ #separate positional & optional arguments
$n+=1;
if (grep {/^-/} $ARGV[$n]){
(my $option= $ARGV[$n]) =~ s/^-+//;
if ($option eq "h" or $option eq "help"){
print $hlp_msg."\n";
exit 0;
}
if (grep {$_ eq $option} @iftrue_opts){
$options_set{$option} = "";
push @to_remove, $n;
} elsif (grep {$_ eq $option} @toget_opts){
if ($n == $#ARGV) {die "ERROR: No value passed to $ARGV[$n]!\n"}
if (grep {/^-/} $ARGV[$n+1]) {die "ERROR: Invalid value $ARGV[$n+1] passed to $ARGV[$n]!\n"}
$options_set{$option} = $ARGV[$n+1];
push @to_remove, ($n,$n+1);
$n+=1
} else {die "ERROR: Invalid option $ARGV[$n]!\n"}
}
}
for (reverse @to_remove){ # remove optional arguments (now saved in %options_set) from the input to get positional arguments
splice @ARGV, $_, 1
}
if ($#ARGV == -1){ # check correct number of positional arguments
die "ERROR: No bam file, VCF file and output name is given!\n"
} elsif ($#ARGV < 1){
die "ERROR: No VCF file and output name is given!\n"
} elsif ($#ARGV < 2){
die "ERROR: No output name is given!\n"
} elsif ($#ARGV > 2){
die "ERROR: Too many positional arguments given!\n"
}
for (my $i=0; $i<14; $i+=2){ # check doubly given value getting options
if (exists $options_set{$toget_opts[$i]} and exists $options_set{$toget_opts[$i+1]}) {die "ERROR: Only one of -$toget_opts[$i] and --$toget_opts[$i+1] allowed!\n"}
}
for (my $i=0; $i<2; $i+=2){ # check doubly given set true options
if (exists $options_set{$iftrue_opts[$i]} and exists $options_set{$iftrue_opts[$i+1]}) {die "ERROR: Only one of -$iftrue_opts[$i] and --$iftrue_opts[$i+1] allowed!\n"}
}
if (exists $options_set{maxMISS}){ # check the given SNP missing rate
if (not looks_like_number($options_set{maxMISS})){
die "ERROR: the SNP missing rate must be a number!\n"
} elsif ($options_set{maxMISS}>1 or $options_set{maxMISS}<0) {
die "ERROR: the SNP missing rate must be between 0 and 1 (0<=maxMISS<=1)!\n"
} else {
$options_set{maxMISS}+=1e-06
}
} else {
print STDERR "WARNING: No maximum missing rate is specified and hence no filtering of SNPs will be performed!\n";
$options_set{maxMISS}=2
}
if (exists $options_set{contig} or exists $options_set{c}){ # check if contig name is given or not
if (not exists $options_set{contig}){
$options_set{contig}=$options_set{c};
delete $options_set{c}
}
}
(-f $ARGV[0]) or die "ERROR: could not find the bam file ${ARGV[0]}!\n";
(-f $ARGV[1]) or die "ERROR: could not find the VCF file ${ARGV[1]}!\n";
if (exists $options_set{contig}){ # extract contig reads from the original BAM fmile
if (! -f "$ARGV[0].bai"){
print STDERR "WARNING: Cannot find the index of the input bam file: $ARGV[0].bai. samtools index is being run...\n";
my $indx=system("samtools index $ARGV[0]");
$indx ? die "ERROR: Indexing failed!\n$!\n" : print STDERR "Succeffully indexed the bam file...\n"
}
my $get_reads = system("samtools idxstats $ARGV[0]|grep -m 1 $options_set{contig} |awk '{print \"\\\"\"\$1\":0-\"\$2\"\\\"\"}'|xargs samtools view -bh $ARGV[0] > $contig_bam");
!$get_reads or die "Cannot extract $options_set{contig} reads from $ARGV[0]: $!\n";
$ARGV[0] = $contig_bam;
} else {
print STDERR "WARNING: No contig name has been specified! The BAM and VCF files must contain only one contig!\n"
}
if ($options_set{maxMISS}<2 or exists $options_set{contig}) { # filter VCF file if contig and/or maxMISS are given
my $ctg_found = 0;
open($fh2,">",$contig_vcf); # extract contig variants from the original VCF file
open(my $fh_vcf, "<", $ARGV[1]) or die "Cannot open $ARGV[1]: $!\n";
SEARCH: {
while (my $line = <$fh_vcf>){
chomp $line;
if (grep {/^#/} $line){
printf $fh2 "%s\n", $line;
} else {
my $vcf_ctg = (split /\t/, $line)[0];
if (!(exists $options_set{contig}) or $vcf_ctg eq $options_set{contig}) {
$ctg_found+=1;
my $missing = 0;
if ($options_set{maxMISS}<2) { # filter SNPs using maxMISS rate
my @genos = split /\t/, $line;
my @non_missing_genos = grep {/([0-9](\/|\|))+/} map {(split /:/, $_)[0]} @genos[9..$#genos];
$missing = ($#{genos}-9-$#{non_missing_genos})/($#{genos}+1-9);
}
if ($missing < $options_set{maxMISS}){
printf $fh2 "%s\n", $line
}
} elsif ($ctg_found>0) { # avoid reading the rest of the VCF file after finding the desired contig
last SEARCH;
}
}
}
}
close($fh_vcf);
close($fh2);
}
my $break_vcf = !system("${PopPoly_Path}/break_vcf.sh ${contig_vcf} ${contig_vcf_broken}"); # break complex variants and throw out indels using break_vcf.py
$break_vcf or die "Couldn't break the complex variants and throw out indels from the VCF file: $!\n";
$ARGV[1] = $contig_vcf_broken;
if (exists $options_set{contig}) {delete $options_set{contig}} # not passed to PopPoly main
if (exists $options_set{maxMISS}) {delete $options_set{maxMISS}} # not passed to PopPoly main
my %new_options_set;
for (keys %options_set){
if (length($_)==1){
$new_options_set{"-$_"}=$options_set{$_}
} else {
$new_options_set{"--$_"}=$options_set{$_}
}
}
undef %options_set;
my $phasing = system((join " ","${PopPoly_Path}/main.py", @ARGV)." ".(join " ", map { $new_options_set{$_} eq "" ? "$_" : "$_ $new_options_set{$_}" } (keys %new_options_set)));
!$phasing or die "ERROR: failed to run PopPoly: $!\n";
END {
unlink "${contig_bam}" if (-f "${contig_bam}");
unlink "${contig_vcf}" if (-f "${contig_vcf}");
unlink "${contig_vcf_broken}" if (-f "${contig_vcf_broken}");
}
README.md 0 → 100755
View file @ c9ab2fce
PopPoly, version 2.2, Ehsan Motazedi (ehsan.motazedi@gmail.com), last modified: Aug 15 2018
Introduction
============
**PopPoly** \(executable *main.py*\) is a tool for haplotype estimation in polyploid F1 populations. PopPoly uses all of the population reads to estimate the maximum likelihood parental haplotypes, from which offspring haplotypes are selected using the MEC criterion.
The algorithm is based on a Bayesian framework to choose the most likely parental haplotypes using sequence reads, and applies Mendelian inheritance rules, assuming no recombination between the SNPs, to weight each candidate phasing for the parents and to later choose the offspring phasings from the parental haplotypes. It can also re-assign the dosages for all or missing SNPs using the Mendelian rules and sequence reads. The name of the parents in the F1 population must be provided as input parameter, with the possibility to specify just one parent in self-fertilizing populations. Otherwise the first two samples registered in the BAM header will be counted as parents. Also, the VCF file must contain only SNPs, that is to say no complex variants and indels. This can be achieved by running the *break_vcf.sh* script on the original VCF file.
PopPoly is written in *Python* and is compatible with both Python 2 and Python 3. There is also a perl wrapper available *PopPoly_wrapped.pl* to directly use input files that contain multiple contigs, in which case one has to specify the name of the desired contig for haplotyping through the wrapper option. The wrapper also allows to filter SNPs based upon their genotype missing rate in the population and can be run using the original VCF file as it calls break_vcf.sh internally (see PopPoly_wrapped.pl -h).
It is also possible to exclude some of the individuals from analysis, for example if several replicates of the same sample are present under different names and one wishes to use only one of them. The space separated names of the to be excluded individuals must be stord in the shell environment in a variable called *exclude* before running PopPoly, as follows:
export exclude="sample_1_replciate_2 sample_2_replicate_1 sample_3_replicate_2 sample_3_replicate_3"
Note that PopPoly relies on *pysam* and *numpy*, which must have been properly installed before PopPoly is called. Some users have reported problems with *numpy undefined symbol*, a discussion of which can be found [here] (https://stackoverflow.com/questions/36190757/numpy-undefined-symbol-pyfpe-jbuf).
Input parameters:
=====================
For the input parameters, see the help of the software:
./main.py --help, -h
***Example:***
./main.py bamfile vcffile output_dirname --kappa 0.85 -a 0.8 --rho 0.2 --impute
Citation:
=====================
To cite PopPoly, please refer to *Family-based haplotype estimation and allele dosage correction for polyploids using short sequence reads*, Ehsan Motazedi, Chris Maliepaard, Richard Finkers and Dick de Ridder, 2018, bioRxiv 318196; *doi: https://doi.org/10.1101/318196*
Download:
=====================
The software is available at gitlab, Wageningen UR:
git clone git@git.wageningenur.nl:motaz001/PopPoly.git —recursive
Copyright and License:
=====================
Copyright (c) 2017, Ehsan Motazedi, Wageningen UR.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files \(the "Software"\), to deal in the Software without restriction, including without limitation the rights to use, copy, share and modify the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. This permission is only valid for academic and personal use, i.e. not for commercial purposes.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
bamprocess.py 0 → 100755
View file @ c9ab2fce
# Make the SNP-fragment list from a multi-sample bam file and its corresponding VCF file with input options: mmq, mbq, maxIS and qoffset.
# Written by Ehsan Motazedi, Wageningen UR, 04-11-2016.
# Last mofified: 22-02-2018.
import copy
import pysam
import re
import subprocess
from genotypes import getAllelesPop, getGenotypesPop
from math import log
from reads import Read
def adjust_seq(read):
""" Adjust the read sequence according to the mapped positions, i.e. get read of the insertions and clipped bases."""
cig = list(_x for _x in re.split('[0-9]{1,}', read.cigarstring) if _x)
cign = list(_x for _x in re.split('[^0-9]', read.cigarstring) if _x)
cig = list(cig[_n]*int(cign[_n]) for _n in range(0, len(cig)))
cig = ''.join(_x for _x in cig if 'D' not in _x) # deleted nucleotides from the reference are not present in the read sequence
adj_seq = []
adj_qual = []
for _n, _x in enumerate(read.seq):
if cig[_n]=='M': # Allow only match/mismatch of the read nucleotides, i.e. no clipping, no insertion.
adj_qual.append(read.qual[_n])
adj_seq.append(_x)
return ''.join(adj_seq), adj_qual
def frag_gen(varpos, allelelst, genolst, coordinates, nucleotides, qscores):
""" Generate SNP-fragments from (paired-end) reads."""
if (not coordinates) or (not nucleotides):
return Read(), {}
var_codes = []
var_num = []
var_q = []
for _n, _x in enumerate(varpos):
if _x < coordinates[0]:
continue
if _x > coordinates[-1]:
break
if _x in coordinates:
if set(genolst[_n].GetGenes()).intersection(set(['.','-'])): # Throw away missing genotypes or genotypes with one or more missing allele(s)
continue
if len(set(genolst[_n].GetGenes()))<2: # Do not include in the SNP-fragments belonging to a population member its homozygous alleles
continue
try:
var_codes.append(allelelst[_n][2][nucleotides[coordinates.index(_x)]])
var_num.append(allelelst[_n][0])
var_q.append(qscores[coordinates.index(_x)])
except KeyError: # if the called nucleotide is wrong, i.e. does not exist in VCF alleles
pass
try: # return the reads {SNP number: allele} and the associated quality scores {SNP number: Qscore}
return Read({_x:str(_y) for _x, _y in zip([var_num[0], var_num[1]]+var_num[2:], var_codes)}), {_x:str(_y) for _x, _y in zip(var_num, var_q)}
except IndexError: # throw away reads with less than 2 SNPs
return Read(), {}
class InputError(Exception):
""" Handle invalid input specifications."""
def __init__(self, msg, *args):
super(InputError, self).__init__(args)
self.msg = msg
def __str__(self):
return "InputError: {}\n".format(self.msg)
def __repr__(self):
return (self.msg,)+self.args+('\n',)
def get_frags(bamfile, vcffile, maxIS=3000, mbq=13, mmq=20, qoffset=33):
"""
mmq : minimum read mapping quality to consider a read for phasing, default 20\n
qvoffset <33/64> : quality value offset, 33/64 depending on how quality values were encoded, default is 33\n
mbq : minimum base quality to consider a base for haplotype fragment, default 13\n
maxIS : maximum insert-size for a paired-end read to be considered as a single fragment for phasing, default 3000.\n
"""
try:
all_reads = pysam.Samfile(bamfile, 'rb')
except IOError:
raise InputError('The input BAM file was not found!')
ReadHeader = subprocess.Popen(["samtools","view","-H", bamfile], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
header, err_header = ReadHeader.communicate()
if ReadHeader.returncode!=0:
raise InputError('Failed to read the header from the bam file! Original error message:\n'+err_header)
if isinstance(header, bytes):
header=bytes.decode(header)
else:
pass
RGIDs, SMnames = [], []
for _headerline in header.splitlines(): # pasre the header of the bam file to extract the ID and SM fields of each Read Group
if _headerline[0:3]=='@RG':
RGID_added, SM_added = False, False
for _n, _field in enumerate(_headerline.split()):
if 'ID' in _field:
if not RGID_added:
RGIDs.append(''.join(_headerline.split()[_n].split(':')[1:])) # add read group ID
RGID_added = True
else:
raise InputError('Double ID fields detected in @RG header line!')
elif 'SM' in _field:
if not SM_added:
SMnames.append(''.join(_headerline.split()[_n].split(':')[1:])) # add the sample name associated with the read group ID
SM_added = True
else:
raise InputError('Double SM fields detected in @RG header line!')
if SM_added and RGID_added:
pass
elif SM_added:
raise InputError('ID field missing in @RG header line!')
elif RGID_added:
raise InputError('SM field missing in @RG header line!')
else:
raise InputError('ID and SM fields missing in @RG header line!')
if len(RGIDs)!=len(set(RGIDs)):
raise InputError('Duplicate read group IDs detected in the bam header!')
GroupedReadsWithID = [[] for _id in RGIDs] # separate reads belonging to each Read Group
for _read in all_reads:
GroupedReadsWithID[RGIDs.index(dict(_read.get_tags())['RG'])].append(_read)
GroupedReads, GroupedSM = [], [] # combine the reads with different RGID but the same SM as they are assumed to belong to the same sample
for _SMname, _ReadGroup in zip(SMnames, GroupedReadsWithID):
if _SMname not in GroupedSM:
GroupedReads.append(_ReadGroup)
GroupedSM.append(_SMname)
else:
GroupedReads[GroupedSM.index(_SMname)]+=_ReadGroup
del GroupedReadsWithID
try:
genolst = getGenotypesPop(vcffile, GroupedSM)
allelelst = getAllelesPop(vcffile, GroupedSM)
except IOError:
raise InputError('The VCF file was not found!')
except:
raise
Frag_lsts, Q_lsts = [], []
varpos = list(_x[1] for _x in allelelst)
for _group, reads in enumerate(GroupedReads):
frag_lst, q_lst = [], []
reads = sorted(reads, key= lambda _x: (_x.qname, _x.flag & 0x900)) # sort the alignments using their names, with the primary alignments being placed first.
_rnum = 0
rNUM = len(reads)
while _rnum < rNUM: # scan through the alignments to find the pairs/singles
break_mate = False
is_proper_pair = False
read = copy.deepcopy(reads[_rnum])
if read.is_unmapped or read.is_duplicate or (read.flag & 0x900): # throw away unmapped reads, duplicates and secondary/supplementary alignments
_rnum+=1
continue
try:
if read.qname == reads[_rnum+1].qname: # means the read is paired to a mate or has multiple/supplemenatry alignments
if reads[_rnum+1].is_unmapped or reads[_rnum+1].is_duplicate or (reads[_rnum+1].flag & 0x900): # if the next read is unmapped, a duplicate or not primarym: skip it
pass
else:
is_proper_pair = True # means the read is paired to a proper mate
mate = copy.deepcopy(reads[_rnum+1])
_rnum+=2
else: # means the read is single
_rnum+=1
except IndexError: # could occur for the last read in the alignments' list
_rnum+=1
if is_proper_pair:
if (max(mate.positions+read.positions)-min(mate.positions+read.positions)+1)>maxIS: # Check the maximum insert-size to consider the mates as a single fragment
break_mate = True
if read.mapping_quality >= mmq:
try:
adj_seq, adj_qual = adjust_seq(read)
coordinates, nucleotides, quals = list(zip(*[(int(_x), _y, _z) for _x, _y, _z in zip(read.positions, adj_seq.upper(), list(ord(_x)-qoffset for _x in adj_qual)) if _z>=mbq]))
except ValueError as e:
if e.args[0][0:len("need more than 0 values to unpack")]=="need more than 0 values to unpack" or e.args[0][0:len("not enough values to unpack")]=="not enough values to unpack":
coordinates, nucleotides, quals= [(), (), ()]
else:
raise
else:
coordinates, nucleotides, quals = [(), (), ()]
if mate.mapping_quality >= mmq:
try:
adj_seq, adj_qual = adjust_seq(mate)
coordinates_mate, nucleotides_mate, quals_mate = list(zip(*[(int(_x), _y, _z) for _x, _y, _z in zip(mate.positions, adj_seq.upper(), list(ord(_x)-qoffset for _x in adj_qual)) if _z>=mbq]))
except ValueError as e:
if e.args[0][0:len("need more than 0 values to unpack")]=="need more than 0 values to unpack" or e.args[0][0:len("not enough values to unpack")]=="not enough values to unpack":
coordinates_mate, nucleotides_mate, quals_mate = [(), (), ()]
else:
raise
else:
coordinates_mate, nucleotides_mate, quals_mate = [(), (), ()]
if break_mate:
pass
else: # merge the sub-reads if the insert-size is less than maxIS
try:
coordinates, nucleotides, quals = list(zip(*sorted(zip(coordinates+coordinates_mate, nucleotides + nucleotides_mate, quals+quals_mate), key = lambda x: x[0])))
except ValueError as e:
if e.args[0][0:len("need more than 0 values to unpack")]=="need more than 0 values to unpack" or e.args[0][0:len("not enough values to unpack")]=="not enough values to unpack":
coordinates, nucleotides, quals = [(), (), ()]
else:
raise
else:
break_mate = True
if read.mapping_quality >= mmq:
try:
adj_seq, adj_qual = adjust_seq(read)
coordinates, nucleotides, quals = list(zip(*[(int(_x), _y, _z) for _x, _y, _z in zip(read.positions, adj_seq.upper(), list(ord(_x)-qoffset for _x in adj_qual)) if _z>=mbq]))
except ValueError as e:
if e.args[0][0:len("need more than 0 values to unpack")]=="need more than 0 values to unpack" or e.args[0][0:len("not enough values to unpack")]=="not enough values to unpack":
coordinates, nucleotides, quals = [(), (), ()]
else:
raise
else:
coordinates, nucleotides, quals = [(), (), ()]
coordinates_mate, nucleotides_mate, quals_mate = [(), (), ()]
if break_mate:
pass
else:
unique_q = []
unique_c = []
unique_n = []
for _n, _c in enumerate(coordinates): # remove the duplicates from overlapping positions
try:
if unique_c[-1]!=_c:
#print("\nN:\n",nucleotides, "\nQ:\n", quals)
unique_c.append(_c)
unique_n.append(nucleotides[_n])
unique_q.append(quals[_n])
elif unique_n[-1]==nucleotides[_n]:
unique_q[-1] = min(126-qoffset, unique_q[-1]+quals[_n])
else: # if the called nucleotides differ at overlapping sites, use the one with the highest Phred score and adjust the Phred score.
if quals[_n]>unique_q[-1]:
_new_q_score = round(-10*log(1-10**(-unique_q[-1]/10)*(1-10**(-quals[_n]/10)), 10), 5) # Q=-10log(p,10)
if _new_q_score >= mbq:
unique_n[-1] = nucleotides[_n]
unique_q[-1] = _new_q_score
else:
del(unique_c[-1], unique_n[-1], unique_q[-1])
else:
_new_q_score = round(-10*log(1-(1-10**(-unique_q[-1]/10))*10**(-quals[_n]/10), 10), 5)
if _new_q_score >= mbq:
unique_q[-1] = _new_q_score
else:
del(unique_c[-1], unique_n[-1], unique_q[-1])
except IndexError:
unique_c.append(_c)
unique_n.append(nucleotides[_n])
unique_q.append(quals[_n])
coordinates, nucleotides, quals = [unique_c, unique_n, unique_q]
coordinates = list(_x+1 for _x in coordinates) # Convert the zero-based BAM coordinates to 1-based, as the coordinates are 1-based in the VCF (like the SAM format).
new_frag, new_q = frag_gen(varpos, allelelst, genolst[_group], coordinates, nucleotides, quals)
frag_lst.append(new_frag)
q_lst.append(new_q)
if break_mate:
coordinates_mate = list(_x+1 for _x in coordinates_mate)
new_frag_mate, new_q_mate = frag_gen(varpos, allelelst, genolst[_group], coordinates_mate, nucleotides_mate, quals_mate)
frag_lst.append(new_frag_mate)
q_lst.append(new_q_mate)
try:
frag_lst, q_lst = [_lst for _lst in zip(*[(_x, _y) for _x, _y in zip(frag_lst, q_lst) if not _x.isNULL()])]
except ValueError as e:
if e.args[0][0:len("need more than 0 values to unpack")]=="need more than 0 values to unpack" or e.args[0][0:len("not enough values to unpack")]=="not enough values to unpack":
frag_lst, q_lst = [], []
Frag_lsts.append(frag_lst)
Q_lsts.append(q_lst)
return Frag_lsts, Q_lsts, GroupedSM
bamprocess.pyc 0 → 100644
View file @ c9ab2fce
File added
branchprune.py 0 → 100755
View file @ c9ab2fce
This diff is collapsed.
branchprune.pyc 0 → 100644
View file @ c9ab2fce
File added
branchprune_aanvullend.py 0 → 100755
View file @ c9ab2fce
This diff is collapsed.
break_vcf.sh 0 → 100755
View file @ c9ab2fce
# Break complex variants and throw out indels from the input vcf file. i
# EX: ./break_vcf.sh my.vcf out.vcf
# Written by Ehsan Motazedi, Wageningen UR, 17-10-2017
# Last Modified: 27-07-2018
file=$1
outfile=$2
tmpfile=$(mktemp /tmp/dummy.XXXXXX)
exec 3> "$tmpfile" #open tmpfile for writing on file descpritor 3
python << EOS
import re
with open("$file", 'rU') as vcf, open("$tmpfile", "w") as recoded:
detected_SNPs = dict()
for line in vcf:
if line.lstrip()[0]=='#':
recoded.write(line)
else:
fields = line.split()
contig = fields[0]
if contig not in detected_SNPs.keys():
detected_SNPs[contig] = []
if '.' in fields[3] or '.' in fields[4]: #indels
pass
elif ',' in fields[4]: # multi-allelic variants
_temp_alts = fields[4].split(',')
if not all(len(_alt)==len(fields[3]) for _alt in _temp_alts): # do not parse complex variants that contain indels
pass
else: # break complex variants into bi-allelic SNPs if possible
difflocation = []
diff_ref_alts = []
diff_ref_alts_dic = []
for _base in range(0, len(fields[3])):
ref_alt = [fields[3][_base]] + [_x for _x in set(_alt[_base] for _alt in _temp_alts)-set([fields[3][_base]])] # check at each position within the complex variant if ref, alt corresponds to a SNP
if len(ref_alt)>1:
ref_alt_dic = {ref_alt[_n]:str(_n) for _n in range(0, len(ref_alt))}
ref_alt_dic['.']='.' # missing genotype added
difflocation.append(_base)
diff_ref_alts.append(ref_alt)
diff_ref_alts_dic.append(ref_alt_dic)
for _n in range(0, len(difflocation)):
_pos = str(int(fields[1])+difflocation[_n])
if (_pos not in detected_SNPs[contig]):
recoded.write(fields[0]+'\t'+_pos+'\t'+fields[2]+'\t'+diff_ref_alts[_n][0]+'\t'+','.join(diff_ref_alts[_n][1:])+'\t'+'\t'.join(fields[5:9]))
for _genotype in fields[9:]:
_dosage = re.split('/|\|', _genotype.split(':')[0])
_old_dic = {'0':diff_ref_alts[_n][0], '.':'.'} #'.' stands for missing genotypes
_old_dic.update({str(_m+1):_temp_alts[_m][difflocation[_n]] for _m in range(0, len(_temp_alts))})
_new_dosage = '/'.join(diff_ref_alts_dic[_n][_old_dic[_allele]] for _allele in _dosage)
recoded.write('\t'+_new_dosage+':'+':'.join(_genotype.split(':')[1:]))
recoded.write('\n')
detected_SNPs[contig].append(_pos)
else:
pass
elif len(fields[3])!=len(fields[4]): #indels
pass
elif len(fields[3])==1: #biallelic SNPs
if (fields[1] not in detected_SNPs[contig]):
recoded.write(line)
detected_SNPs[contig].append(fields[1])
else:
pass
else: # MNPs
difflocation = []
for _n in range(0, len(fields[3])):
if fields[3][_n]!=fields[4][_n]:
difflocation.append(_n)
for _n in range(0, len(difflocation)):
_pos = str(int(fields[1])+difflocation[_n])
if (_pos not in detected_SNPs[contig]):
recoded.write(fields[0]+'\t'+_pos+'\t'+fields[2]+'\t'+fields[3][difflocation[_n]]+'\t'+fields[4][difflocation[_n]]+'\t'+'\t'.join(fields[5:])+'\n')
detected_SNPs[contig].append(_pos)
else:
pass
EOS
cp $tmpfile $outfile
status=$?
if [ $status -eq 0 ]; then
rm $tmpfile
fi
genotypes.py 0 → 100755
View file @ c9ab2fce
# Written by Ehsan Motazedi, Wageningen UR, 04-11-2016.
# Last Updated: 30-08-2018
import copy
import re
import sys
from collections import Counter
from Bio import SeqIO
class Genotype(object):
def __init__(self, numS, pos, *genotype):
try:
self.s = int(numS)
self.pos = int(pos)
except (ValueError, TypeError) as e:
e.args+=("The SNP id and SNP position must be inetgers!",)
self.genotype = copy.deepcopy(genotype)
def __repr__(self):
return '['+','.join(str(_x) for _x in (self.s, self.pos))+','+','.join(str(_x) for _x in self.genotype)+']'
def __str__(self):
return "SNP number = {}, SNP position = {}, Genotype = {}".format(self.s, self.pos,
'/'.join(str(_x) for _x in self.genotype))
def __eq__(self, other):