Ejemplo n.º 1
0
        private static MixtureModelResult GetModelResult(CalledAllele allele, RecalibrationResult result)
        {
            var recal = new RecalibratedVariantsCollection();

            recal.AddLocus(allele);
            return(MixtureModel.UsePrefitModel(recal.Ad, recal.Dp, result.Means, result.Priors).PrimaryResult);
        }
Ejemplo n.º 2
0
        private static CalledAllele ProcessDeletion(CalledAllele deletionVar, CalledAllele variant, AlleleReader reader,
                                                    RecalibratedVariantsCollection snvLoci, RecalibratedVariantsCollection indelLoci)
        {
            CalledAllele lastVar;

            for (int i = 1; i < deletionVar.ReferenceAllele.Length; i++)
            {
                if (ShouldSkipVariant(variant))
                {
                    continue;
                }

                if (variant.HasAnAltAllele)
                {
                    if (GetVariantType(variant) == VariantType.Snv)
                    {
                        snvLoci.AddLocus(variant);
                    }
                    else
                    {
                        indelLoci.AddLocus(variant);
                    }
                }

                lastVar = variant;
                variant = new CalledAllele();

                GetNextUncrushedAllele(reader, out variant);

                // If there is multiallelic variant inside deletion, ignore locus
                if (variant.IsCoLocatedAllele(lastVar) && lastVar.HasAnAltAllele)
                {
                    if (GetVariantType(lastVar) == VariantType.Snv)
                    {
                        snvLoci.RemoveLastEntry();
                    }
                    else
                    {
                        indelLoci.RemoveLastEntry();
                    }
                }
                while (variant.ReferencePosition == lastVar.ReferencePosition &&
                       variant.Chromosome == lastVar.Chromosome)
                {
                    lastVar = variant;
                    variant = new CalledAllele();
                    GetNextUncrushedAllele(reader, out variant);
                }

                if (variant.ReferencePosition > deletionVar.ReferencePosition + deletionVar.ReferenceAllele.Length - 1 &&
                    variant.Chromosome == deletionVar.Chromosome)
                {
                    break;
                }
            }

            return(variant);
        }
Ejemplo n.º 3
0
        public static List <RecalibratedVariantsCollection> GetVariantFrequencies(string vcfIn)
        {
            CalledAllele variant = new CalledAllele();
            CalledAllele lastVar = new CalledAllele();

            var snvLoci   = new RecalibratedVariantsCollection();
            var indelLoci = new RecalibratedVariantsCollection();

            var alleleReader = new AlleleReader(vcfIn);

            // Check headers
            CheckHeader(alleleReader);

            using (alleleReader)
            {
                while (GetNextUncrushedAllele(alleleReader, out variant))
                {
                    try
                    {
                        // Check if multiallelic
                        if (variant.IsCoLocatedAllele(lastVar))
                        {
                            variant = ProcessMultiAllelicVariant(lastVar, variant, alleleReader, snvLoci, indelLoci);
                        }

                        // Check if within deletion
                        if (lastVar.ReferenceAllele != null && variant != null &&
                            lastVar.ReferenceAllele.Length > 1 &&
                            lastVar.Genotype != Genotype.HomozygousRef &&
                            variant.ReferencePosition == lastVar.ReferencePosition + 1)
                        {
                            variant = ProcessDeletion(lastVar, variant, alleleReader, snvLoci, indelLoci);
                        }


                        // this happens if last variants in file are multi-allelic or a deletion
                        if (variant == null)
                        {
                            break;
                        }

                        if (ShouldSkipVariant(variant) || !variant.Chromosome.Any(char.IsDigit))
                        {
                            continue;
                        }

                        var variantType = GetVariantType(variant);
                        if (variantType == VariantType.NoVariant)
                        {
                            snvLoci.AddLocus(variant);
                            indelLoci.AddLocus(variant);
                        }
                        else if (variantType == VariantType.Snv)
                        {
                            snvLoci.AddLocus(variant);
                        }
                        else if (variantType == VariantType.Indel)
                        {
                            indelLoci.AddLocus(variant);
                        }

                        lastVar = variant;
                        variant = new CalledAllele();
                    }

                    catch (Exception ex)
                    {
                        Logger.WriteToLog(string.Format("Fatal error processing vcf; Check {0}, position {1}.  Exception: {2}",
                                                        variant.Chromosome, variant.ReferencePosition, ex));
                        throw;
                    }
                }
            }
            return(new List <RecalibratedVariantsCollection> {
                snvLoci, indelLoci
            });
        }