/****************************************************
* OUTPUT A SINGLE MARKER RECORD TO raw OUTPUT FILE *
****************************************************/
void print_record(FILE *temp_f, char *marker_name, char marker_type[MARKER_TYPE_LEN], bcf_fmt_t *fmt_ptr,
int n_progeny, int idx_progeny[], const char * const(*type_ptr)[GT_TYPES_LEN]) {
int i, ial, jal;
fprintf(temp_f, "*%s\t%s\t", marker_name, marker_type);
int cur_prog_gt = bcf_gt_type(fmt_ptr, idx_progeny[0], &ial, &jal);
fprintf(temp_f, "%s", (*type_ptr)[cur_prog_gt]);
for (i = 1; i < n_progeny; i++) {
cur_prog_gt = bcf_gt_type(fmt_ptr, idx_progeny[i], &ial, &jal);
fprintf(temp_f, " %s", (*type_ptr)[cur_prog_gt]);
}
fprintf(temp_f, "\n");
}
/**********************************************************
* CALL PARENT GENOTYPES GIVEN ONE OR MORE SAMPLE INDICES *
**********************************************************/
void get_consensus_parent_gt(bcf_fmt_t *fmt_ptr, int n_parent, int idx_parent[], int min_class_parent,
bool* is_het_parent, bool* is_hom_ref_parent, bool* is_hom_alt_parent) {
int i, ial, jal;
// We only consider the following genotypes (https://github.com/samtools/htslib/blob/develop/htslib/vcfutils.h)
// 0: Homozygous reference allele
// 1: Homozygous alternative allele (and assume there is only one alternative allele in variant locus)
// 2: Heterozygous ref/alt
int count_parent[3] = {0};
for (i = 0; i < n_parent; i++) {
int cur_gt = bcf_gt_type(fmt_ptr, idx_parent[i], &ial, &jal);
if (cur_gt <= 2 && cur_gt >= 0) {
count_parent[cur_gt]++;
}
}
// First, decide whether parent is heterozygous
if (count_parent[GT_HET_RA]) {
if (count_parent[GT_HET_RA] >= min_class_parent) {
*is_het_parent = true;
}
}
// If not, check whether it is REF allele homozygous or ALT allele homozygous
else if (count_parent[GT_HOM_RR] && !count_parent[GT_HOM_AA]) {
if (count_parent[GT_HOM_RR] >= min_class_parent) {
*is_hom_ref_parent = true;
}
}
else if (!count_parent[GT_HOM_RR] && count_parent[GT_HOM_AA]) {
if (count_parent[GT_HOM_AA] >= min_class_parent) {
*is_hom_alt_parent = true;
}
}
}
int subset_vcf(args_t *args, bcf1_t *line)
{
if ( args->min_alleles && line->n_allele < args->min_alleles ) return 0; // min alleles
if ( args->max_alleles && line->n_allele > args->max_alleles ) return 0; // max alleles
if (args->novel || args->known)
{
if ( args->novel && (line->d.id[0]!='.' || line->d.id[1]!=0) ) return 0; // skip sites which are known, ID != '.'
if ( args->known && line->d.id[0]=='.' && line->d.id[1]==0 ) return 0; // skip sites which are novel, ID == '.'
}
if (args->include || args->exclude)
{
int line_type = bcf_get_variant_types(line);
if ( args->include && !(line_type&args->include) ) return 0; // include only given variant types
if ( args->exclude && line_type&args->exclude ) return 0; // exclude given variant types
}
if ( args->filter )
{
int ret = filter_test(args->filter, line, NULL);
if ( args->filter_logic==FLT_INCLUDE ) { if ( !ret ) return 0; }
else if ( ret ) return 0;
}
hts_expand(int, line->n_allele, args->mac, args->ac);
int i, an = 0, non_ref_ac = 0;
if (args->calc_ac) {
bcf_calc_ac(args->hdr, line, args->ac, BCF_UN_INFO|BCF_UN_FMT); // get original AC and AN values from INFO field if available, otherwise calculate
for (i=1; i<line->n_allele; i++)
non_ref_ac += args->ac[i];
for (i=0; i<line->n_allele; i++)
an += args->ac[i];
}
if (args->n_samples)
{
int non_ref_ac_sub = 0, *ac_sub = (int*) calloc(line->n_allele,sizeof(int));
bcf_subset(args->hdr, line, args->n_samples, args->imap);
if (args->calc_ac) {
bcf_calc_ac(args->hsub, line, ac_sub, BCF_UN_FMT); // recalculate AC and AN
an = 0;
for (i=0; i<line->n_allele; i++) {
args->ac[i] = ac_sub[i];
an += ac_sub[i];
}
for (i=1; i<line->n_allele; i++)
non_ref_ac_sub += ac_sub[i];
if (args->private_vars) {
if (args->private_vars == FLT_INCLUDE && !(non_ref_ac_sub > 0 && non_ref_ac == non_ref_ac_sub)) { free(ac_sub); return 0; } // select private sites
if (args->private_vars == FLT_EXCLUDE && non_ref_ac_sub > 0 && non_ref_ac == non_ref_ac_sub) { free(ac_sub); return 0; } // exclude private sites
}
non_ref_ac = non_ref_ac_sub;
}
free(ac_sub);
}
bcf_fmt_t *gt_fmt;
if ( args->gt_type && (gt_fmt=bcf_get_fmt(args->hdr,line,"GT")) )
{
int nhet = 0, nhom = 0, nmiss = 0;
for (i=0; i<bcf_hdr_nsamples(args->hdr); i++)
{
int type = bcf_gt_type(gt_fmt,i,NULL,NULL);
if ( type==GT_HET_RA || type==GT_HET_AA )
{
if ( args->gt_type==GT_NO_HET ) return 0;
nhet = 1;
}
else if ( type==GT_UNKN )
{
if ( args->gt_type==GT_NO_MISSING ) return 0;
nmiss = 1;
}
else
{
if ( args->gt_type==GT_NO_HOM ) return 0;
nhom = 1;
}
}
if ( args->gt_type==GT_NEED_HOM && !nhom ) return 0;
else if ( args->gt_type==GT_NEED_HET && !nhet ) return 0;
else if ( args->gt_type==GT_NEED_MISSING && !nmiss ) return 0;
}
int minor_ac = 0;
int major_ac = 0;
if ( args->calc_ac )
{
minor_ac = args->ac[0];
major_ac = args->ac[0];
for (i=1; i<line->n_allele; i++){
if (args->ac[i] < minor_ac) { minor_ac = args->ac[i]; }
if (args->ac[i] > major_ac) { major_ac = args->ac[i]; }
}
}
if (args->min_ac)
{
if (args->min_ac_type == ALLELE_NONREF && args->min_ac>non_ref_ac) return 0; // min AC
else if (args->min_ac_type == ALLELE_MINOR && args->min_ac>minor_ac) return 0; // min minor AC
else if (args->min_ac_type == ALLELE_ALT1 && args->min_ac>args->ac[1]) return 0; // min 1st alternate AC
else if (args->min_ac_type == ALLELE_MAJOR && args->min_ac > major_ac) return 0; // min major AC
else if (args->min_ac_type == ALLELE_NONMAJOR && args->min_ac > an-major_ac) return 0; // min non-major AC
}
if (args->max_ac)
{
if (args->max_ac_type == ALLELE_NONREF && args->max_ac<non_ref_ac) return 0; // max AC
else if (args->max_ac_type == ALLELE_MINOR && args->max_ac<minor_ac) return 0; // max minor AC
else if (args->max_ac_type == ALLELE_ALT1 && args->max_ac<args->ac[1]) return 0; // max 1st alternate AC
else if (args->max_ac_type == ALLELE_MAJOR && args->max_ac < major_ac) return 0; // max major AC
else if (args->max_ac_type == ALLELE_NONMAJOR && args->max_ac < an-major_ac) return 0; // max non-major AC
}
if (args->min_af)
{
if (an == 0) return 0; // freq not defined, skip site
if (args->min_af_type == ALLELE_NONREF && args->min_af>non_ref_ac/(double)an) return 0; // min AF
else if (args->min_af_type == ALLELE_MINOR && args->min_af>minor_ac/(double)an) return 0; // min minor AF
else if (args->min_af_type == ALLELE_ALT1 && args->min_af>args->ac[1]/(double)an) return 0; // min 1st alternate AF
else if (args->min_af_type == ALLELE_MAJOR && args->min_af > major_ac/(double)an) return 0; // min major AF
else if (args->min_af_type == ALLELE_NONMAJOR && args->min_af > (an-major_ac)/(double)an) return 0; // min non-major AF
}
if (args->max_af)
{
if (an == 0) return 0; // freq not defined, skip site
if (args->max_af_type == ALLELE_NONREF && args->max_af<non_ref_ac/(double)an) return 0; // max AF
else if (args->max_af_type == ALLELE_MINOR && args->max_af<minor_ac/(double)an) return 0; // max minor AF
else if (args->max_af_type == ALLELE_ALT1 && args->max_af<args->ac[1]/(double)an) return 0; // max 1st alternate AF
else if (args->max_af_type == ALLELE_MAJOR && args->max_af < major_ac/(double)an) return 0; // max major AF
else if (args->max_af_type == ALLELE_NONMAJOR && args->max_af < (an-major_ac)/(double)an) return 0; // max non-major AF
}
if (args->uncalled) {
if (args->uncalled == FLT_INCLUDE && an > 0) return 0; // select uncalled
if (args->uncalled == FLT_EXCLUDE && an == 0) return 0; // skip if uncalled
}
if (args->calc_ac && args->update_info) {
bcf_update_info_int32(args->hdr, line, "AC", &args->ac[1], line->n_allele-1);
bcf_update_info_int32(args->hdr, line, "AN", &an, 1);
}
if (args->trim_alts)
{
int ret = bcf_trim_alleles(args->hsub ? args->hsub : args->hdr, line);
if ( ret==-1 ) error("Error: some GT index is out of bounds at %s:%d\n", bcf_seqname(args->hsub ? args->hsub : args->hdr, line), line->pos+1);
}
if (args->phased) {
int phased = bcf_all_phased(args->hdr, line);
if (args->phased == FLT_INCLUDE && !phased) { return 0; } // skip unphased
if (args->phased == FLT_EXCLUDE && phased) { return 0; } // skip phased
}
if (args->sites_only) bcf_subset(args->hsub ? args->hsub : args->hdr, line, 0, 0);
return 1;
}
int process_region_guess(args_t *args, char *seq, regitr_t *itr)
{
int kitr = 1;
uint32_t start = 0, end = INT_MAX;
reg_stats_t *stats = NULL;
// set the start and the end position
if ( itr )
{
start = itr->reg[itr->i].start;
end = itr->reg[itr->i].end;
// flush all records with the same coordinates
while ( itr->i+kitr<itr->n && start==itr->reg[itr->i+kitr].start && end==itr->reg[itr->i+kitr].end ) kitr++;
int min,max,ret = ploidy_query(args->ploidy, seq, start, args->sex2ploidy, &min, &max);
assert(ret);
stats = expand_regs(args, seq,start,end);
}
else
{
// background region
int spos, epos;
const char *ptr = hts_parse_reg(args->background, &spos, &epos);
if ( !ptr )
error("Could not parse the region: %s\n", args->background);
seq = (char*) malloc(ptr - args->background + 1);
memcpy(seq,args->background,ptr-args->background);
seq[ptr-args->background] = 0;
start = spos;
end = epos;
}
if ( bcf_sr_seek(args->sr,seq,start)!=0 )
{
// sequence not present
if ( !itr ) free(seq);
return kitr;
}
int ismpl, rid = bcf_hdr_name2id(args->hdr,seq);
if ( !itr ) free(seq);
while ( bcf_sr_next_line(args->sr) )
{
bcf1_t *rec = bcf_sr_get_line(args->sr,0);
if ( rec->rid!=rid || rec->pos > end ) break;
if ( args->guess & GUESS_GT ) // use GTs to guess the ploidy
{
bcf_fmt_t *fmt = bcf_get_fmt(args->hdr, rec, "GT");
if ( !fmt ) continue;
for (ismpl=0; ismpl<args->nsample; ismpl++)
{
count_t *counts = stats ? &stats->counts[ismpl] : &args->bg_counts[ismpl];
int gt = bcf_gt_type(fmt, ismpl, NULL,NULL);
if ( gt==GT_UNKN ) counts->nmiss++;
else if ( gt==GT_HET_RA || gt==GT_HET_AA ) counts->nhet++;
else counts->nhom++;
}
}
else // use PLs to guess the ploidy
{
int gl2pl = args->guess & GUESS_PL ? 1 : -1;
int npl = bcf_get_format_int32(args->hdr,rec,args->guess&GUESS_PL?"PL":"GL",&args->pls,&args->npls);
if ( npl<=0 ) continue;
npl /= args->nsample;
for (ismpl=0; ismpl<args->nsample; ismpl++)
{
int32_t *ptr = args->pls + ismpl*npl;
int phom = INT_MAX, phet = INT_MAX, ial, jal, k = 0;
for (ial=0; ial<rec->n_allele; ial++)
{
for (jal=0; jal<ial; jal++)
{
if ( ptr[k] == bcf_int32_missing || ptr[k] == bcf_int32_vector_end ) break;
ptr[k] *= gl2pl;
if ( phet > ptr[k] ) phet = ptr[k];
k++;
}
if ( ptr[k] == bcf_int32_missing || ptr[k] == bcf_int32_vector_end ) break;
ptr[k] *= gl2pl;
if ( phom > ptr[k] ) phom = ptr[k];
k++;
}
count_t *counts = stats ? &stats->counts[ismpl] : &args->bg_counts[ismpl];
if ( k == rec->n_allele ) counts->nhom++; // haploid
else if ( phet == phom || k != rec->n_allele*(rec->n_allele+1)/2 ) counts->nmiss++;
else if ( phet < phom ) counts->nhet++;
else counts->nhom++;
}
}
}
return kitr;
}
