コード例 #1
0
        public void ValidateNUCmerGetClusters()
        {
            // Gets the reference sequence from the FastA file
            string filePath = utilityObj.xmlUtil.GetTextValue(Constants.MediumSizeSequenceNodeName,
                                                              Constants.FilePathNode);

            // Gets the query sequence from the FastA file
            string queryFilePath = utilityObj.xmlUtil.GetTextValue(Constants.MediumSizeSequenceNodeName,
                                                                   Constants.SearchSequenceFilePathNode);

            using (FastAParser parser1 = new FastAParser(filePath))
            {
                using (FastAParser parser2 = new FastAParser(queryFilePath))
                {
                    IEnumerable <ISequence> seqs1 = parser1.Parse();
                    IEnumerable <ISequence> seqs2 = parser2.Parse();
                    NUCmer nuc = new NUCmer((Sequence)seqs1.ElementAt(0));
                    nuc.LengthOfMUM  = 5;
                    nuc.MinimumScore = 0;
                    nuc.BreakLength  = 0;
                    IList <Cluster> clusts = nuc.GetClusters(seqs2.ElementAt(0), true);

                    string clustCount1 = utilityObj.xmlUtil.GetTextValue(Constants.MediumSizeSequenceNodeName,
                                                                         Constants.ClustCount1Node);

                    Assert.AreEqual(clustCount1, clusts.Count.ToString((IFormatProvider)null));
                }
            }
        }
コード例 #2
0
        /// <summary>
        /// Returns the cluster.
        /// </summary>
        /// <param name="referenceSequence">The Reference sequence.</param>
        /// <param name="querySequence">The Query sequence.</param>
        /// <returns>Returns list of clusters.</returns>
        private IList<List<IList<Cluster>>> GetCluster(IEnumerable<ISequence> referenceSequence, IEnumerable<ISequence> querySequence)
        {
            IList<List<IList<Cluster>>> clusters;
            if (this.MaxMatch)
            {
                clusters = referenceSequence.AsParallel().Select(sequence =>
                    {
                        NUCmer nucmer = new NUCmer();
                        nucmer.BreakLength = BreakLength;
                        nucmer.LengthOfMUM = MinMatch;
                        nucmer.MaximumSeparation = MaxGap;
                        nucmer.MinimumScore = MinCluster;
                        nucmer.SeparationFactor = (float)DiagFactor;
                        return nucmer.GetClusters(
                                new List<ISequence> { sequence }, GetSequence(querySequence), false);
                    }).ToList();
            }
            else
            {
                clusters = referenceSequence.AsParallel().Select(sequence =>
                {
                    NUCmer nucmer = new NUCmer();
                    nucmer.BreakLength = BreakLength;
                    nucmer.LengthOfMUM = MinMatch;
                    nucmer.MaximumSeparation = MaxGap;
                    nucmer.MinimumScore = MinCluster;
                    nucmer.SeparationFactor = (float)DiagFactor;
                    return nucmer.GetClusters(new List<ISequence> { sequence }, GetSequence(querySequence));
                }).ToList();
            }

            return clusters;
        }
コード例 #3
0
        /// <summary>
        /// Returns the cluster.
        /// </summary>
        /// <param name="referenceSequence">The Reference sequences.</param>
        /// <param name="originalQuerySequences">The Query sequences.</param>
        /// <returns>Returns list of clusters.</returns>
        private IList <List <IList <Cluster> > > GetCluster(IEnumerable <ISequence> referenceSequence, IEnumerable <ISequence> originalQuerySequences)
        {
            var clusters  = new List <List <IList <Cluster> > >();
            var clusters1 = new List <IList <Cluster> >();

            IEnumerable <ISequence> querySequences =
                Forward ? originalQuerySequences
                        : (Reverse
                            ? ReverseComplementSequenceList(originalQuerySequences)
                            : AddReverseComplementsToSequenceList(originalQuerySequences));

            _queryCount += querySequences.Count();

            foreach (var sequence in referenceSequence)
            {
                NUCmer nucmer = new NUCmer(sequence)
                {
                    FixedSeparation   = FixedSeparation,
                    BreakLength       = BreakLength,
                    LengthOfMUM       = MinMatch,
                    MaximumSeparation = MaxGap,
                    MinimumScore      = MinCluster,
                    SeparationFactor  = (float)DiagFactor
                };

                clusters1.AddRange(querySequences.Select(qs => nucmer.GetClusters(qs, !MaxMatch, qs.IsMarkedAsReverseComplement())));
            }

            clusters.Add(clusters1);

            return(clusters);
        }
コード例 #4
0
        /// <summary>
        /// Returns the cluster.
        /// </summary>
        /// <param name="referenceSequence">The Reference sequence.</param>
        /// <param name="querySequence">The Query sequence.</param>
        /// <returns>Returns list of clusters.</returns>
        private IList <List <IList <Cluster> > > GetCluster(IEnumerable <ISequence> referenceSequence, IEnumerable <ISequence> querySequence)
        {
            IList <List <IList <Cluster> > > clusters  = new List <List <IList <Cluster> > >();
            List <IList <Cluster> >          clusters1 = new List <IList <Cluster> >();

            if (this.MaxMatch)
            {
                Parallel.ForEach(referenceSequence, sequence =>
                {
                    NUCmer nucmer            = new NUCmer((Sequence)sequence);
                    nucmer.FixedSeparation   = FixedSeparation;
                    nucmer.BreakLength       = BreakLength;
                    nucmer.LengthOfMUM       = MinMatch;
                    nucmer.MaximumSeparation = MaxGap;
                    nucmer.MinimumScore      = MinCluster;
                    nucmer.SeparationFactor  = (float)DiagFactor;

                    foreach (ISequence qrySequence in querySequence)
                    {
                        clusters1.Add(nucmer.GetClusters(qrySequence, false));
                    }
                });

                clusters.Add(clusters1);
            }
            else
            {
                Parallel.ForEach(referenceSequence, sequence =>
                {
                    NUCmer nucmer            = new NUCmer((Sequence)sequence);
                    nucmer.FixedSeparation   = FixedSeparation;
                    nucmer.BreakLength       = BreakLength;
                    nucmer.LengthOfMUM       = MinMatch;
                    nucmer.MaximumSeparation = MaxGap;
                    nucmer.MinimumScore      = MinCluster;
                    nucmer.SeparationFactor  = (float)DiagFactor;

                    foreach (ISequence qrySequence in querySequence)
                    {
                        clusters1.Add(nucmer.GetClusters(qrySequence));
                    }
                });

                clusters.Add(clusters1);
            }

            return(clusters);
        }