コード例 #1
0
        /// <summary>
        ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
        ///     intensity by specified intensity.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="intensityNormalizer">
        ///     intensity to normalize the peaks to. assumes that if peak with intensity = normalizer was
        ///     present, it would be normalized to 100
        /// </param>
        /// <param name="mzDelta">
        ///     specifies the mass delta between theoretical and observed m/z. The we are looking to score
        ///     against the feature in the observed data at theoeretical m/z + mzDelta
        /// </param>
        /// <param name="minIntensityForScore">minimum intensity for score</param>
        /// <param name="debug">prints debugging information if this is set to true.</param>
        public override double FitScore(PeakData peakData, int chargeState, double intensityNormalizer, double mzDelta,
                                        double minIntensityForScore, bool debug = false)
        {
            var numPoints = TheoreticalDistMzs.Count;

            if (numPoints < 3)
            {
                return(1);
            }

            double fit = 0;
            double sum = 0;

            for (var pointNum = 0; pointNum < numPoints; pointNum++)
            {
                var mz = TheoreticalDistMzs[pointNum] + mzDelta;
                var theoreticalIntensity = TheoreticalDistIntensities[pointNum];

                if (theoreticalIntensity >= minIntensityForScore)
                {
                    // observed intensities have to be normalized so that the maximum intensity is 100,
                    // like that for theoretical intensities.
                    var observedIntensity = 100 *
                                            GetPointIntensity(mz, peakData.MzList, peakData.IntensityList) /
                                            intensityNormalizer;
                    var intensityDiff = observedIntensity - theoreticalIntensity;
                    var intensitySum  = observedIntensity + theoreticalIntensity;
                    fit += intensityDiff * intensityDiff / intensitySum;
                    sum += theoreticalIntensity * observedIntensity;
                }
            }

            return(fit / (sum + 0.001));
        }
コード例 #2
0
        public string ToXML(FAIMStoMzXMLProcessor processor)
        {
            // place scan byte depth into our tracking list
            var index = new Index(processor.ByteTracking.CurrentScan, processor.ByteTracking.ByteDepth + 3);

            processor.ByteTracking.ScanOffsets.Add(index);

            FilterLine = FixFilterLine();

            var sb = new StringBuilder();

            sb.AppendFormat("   <scan num=\"{0}\"", processor.ByteTracking.CurrentScan).AppendLine();
            sb.AppendFormat("    msLevel=\"{0}\"", MsLevel).AppendLine();
            sb.AppendFormat("    peaksCount=\"{0}\"", PeaksCount).AppendLine();
            sb.AppendFormat("    polarity=\"{0}\"", Polarity).AppendLine();
            sb.AppendFormat("    scanType=\"{0}\"", ScanType).AppendLine();
            sb.AppendFormat("    filterLine=\"{0}\"", FilterLine).AppendLine();
            sb.AppendFormat("    retentionTime=\"{0}\"", RetentionTime).AppendLine();
            sb.AppendFormat("    lowMz=\"" + Math.Round(LowMz, 3) + "\"").AppendLine();
            sb.AppendFormat("    highMz=\"" + Math.Round(HighMz, 3) + "\"").AppendLine();
            sb.AppendFormat("    basePeakMz=\"" + Math.Round(BasePeakMz, 3) + "\"").AppendLine();
            sb.AppendFormat("    basePeakIntensity=\"" + FormatSpecialNumber(BasePeakIntensity) + "\"").AppendLine();
            sb.AppendFormat("    totIonCurrent=\"" + FormatSpecialNumber(TotIonCurrent) + "\"").AppendLine();
            sb.AppendFormat("    collisionEnergy=\"" + CollisionEnergy + "\">").AppendLine();

            sb.AppendLine(PrecursorMz.ToXML());
            sb.AppendLine(PeakData.ToXML(4));
            sb.Append("   </scan>");

            processor.ByteTracking.CurrentScan++;
            return(sb.ToString());
        }
コード例 #3
0
ファイル: Program.cs プロジェクト: lgatto/proteowizard
 private static IList<PeakData> ImportFile(TextReader peakViewReader)
 {
     var peakDatas = new List<PeakData>();
     var msFileNames = new List<string>();
     var fileReader = new DsvFileReader(peakViewReader, TextUtil.SEPARATOR_TSV);
     Debug.Assert(Equals(fileReader.GetFieldIndex(PROTEIN), 0));
     Debug.Assert(Equals(fileReader.GetFieldIndex(PEPTIDE), 1));
     Debug.Assert(Equals(fileReader.GetFieldIndex(LABEL), 2));
     Debug.Assert(Equals(fileReader.GetFieldIndex(PRECURSOR), 3));
     Debug.Assert(Equals(fileReader.GetFieldIndex(CHARGE), 4));
     Debug.Assert(Equals(fileReader.GetFieldIndex(RT), 5));
     Debug.Assert(Equals(fileReader.GetFieldIndex(DECOY), 6));
     for (int i = 7; i < fileReader.NumberOfFields; ++i)
     {
         msFileNames.Add(fileReader.FieldNames[i]);
     }
     while (fileReader.ReadLine() != null)
     {
         string modifiedSequence = fileReader.GetFieldByName(PEPTIDE);
         string decoyString = fileReader.GetFieldByName(DECOY);
         bool decoy;
         var hasDecoyValue = bool.TryParse(decoyString, out decoy);
         Debug.Assert(hasDecoyValue);
         foreach (var msFileName in msFileNames)
         {
             string dataFieldString = fileReader.GetFieldByName(msFileName);
             double dataField;
             var hasDataFieldValue = double.TryParse(dataFieldString, out dataField);
             Debug.Assert(hasDataFieldValue);
             var peakData = new PeakData(dataField, modifiedSequence, msFileName, decoy);
             peakDatas.Add(peakData);
         }
     }
     return peakDatas;
 }
コード例 #4
0
        public IList <PeakData> ImportFile(TextReader peakViewReader)
        {
            var peakDatas   = new List <PeakData>();
            var msFileNames = new List <string>();
            var fileReader  = new DsvFileReader(peakViewReader, TextUtil.SEPARATOR_TSV);

            Assert.AreEqual(fileReader.GetFieldIndex(PROTEIN), 0);
            Assert.AreEqual(fileReader.GetFieldIndex(PEPTIDE), 1);
            Assert.AreEqual(fileReader.GetFieldIndex(LABEL), 2);
            Assert.AreEqual(fileReader.GetFieldIndex(PRECURSOR), 3);
            Assert.AreEqual(fileReader.GetFieldIndex(CHARGE), 4);
            Assert.AreEqual(fileReader.GetFieldIndex(RT), 5);
            Assert.AreEqual(fileReader.GetFieldIndex(DECOY), 6);
            for (int i = 7; i < fileReader.NumberOfFields; ++i)
            {
                msFileNames.Add(fileReader.FieldNames[i]);
            }
            while (fileReader.ReadLine() != null)
            {
                string modifiedSequence = fileReader.GetFieldByName(PEPTIDE);
                string decoyString      = fileReader.GetFieldByName(DECOY);
                bool   decoy;
                Assert.IsTrue(bool.TryParse(decoyString, out decoy));
                foreach (var msFileName in msFileNames)
                {
                    string dataFieldString = fileReader.GetFieldByName(msFileName);
                    double dataField;
                    Assert.IsTrue(double.TryParse(dataFieldString, out dataField));
                    var peakData = new PeakData(dataField, modifiedSequence, msFileName, decoy);
                    peakDatas.Add(peakData);
                }
            }
            return(peakDatas);
        }
コード例 #5
0
 internal static void SetPeaks(ref PeakData peakData, ref clsPeak[] peaks)
 {
     foreach (var pk in peaks)
     {
         peakData.AddPeak(new clsPeak(pk));
     }
     peakData.InitializeUnprocessedPeakData();
 }
コード例 #6
0
ファイル: AreaFitScorer.cs プロジェクト: Acedon95/DeconTools
        /// <summary>
        ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
        ///     intensity by specified intensity.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="peak"> peak for which we want to compute the fit function.</param>
        /// <param name="mzDelta">specifies the mass delta between theoretical and observed m/z with the best fit so far.</param>
        /// <param name="minIntensityForScore">minimum intensity for score</param>
        /// <param name="pointsUsed">number of points used</param>
        /// <param name="debug">debug output flag</param>
        public override double FitScore(PeakData peakData, int chargeState, ThrashV1Peak peak, double mzDelta,
                                        double minIntensityForScore, out int pointsUsed, bool debug = false)
        {
            pointsUsed = 0;

            var numPoints = TheoreticalDistMzs.Count;

            if (numPoints < 3)
            {
                return(1);
            }

            if (peak.Intensity <= 0)
            {
                return(1);
            }

            var maxObservedIntensity = peak.Intensity;

            if (maxObservedIntensity <= 0)
            {
                Console.Error.WriteLine("Peak intensity was <=0 during FitScore. mz = " + peak.Mz +
                                        " , intensity = " + peak.Intensity);
                Environment.Exit(1);
            }

            double fit = 0;
            double sum = 0;

            for (var pointNum = 0; pointNum < numPoints; pointNum++)
            {
                var mz = TheoreticalDistMzs[pointNum] + mzDelta;
                var theoreticalIntensity = (float)TheoreticalDistIntensities[pointNum];
                if (theoreticalIntensity >= minIntensityForScore)
                {
                    // observed intensities have to be normalized so that the maximum intensity is 100,
                    // like that for theoretical intensities.
                    var observedIntensity = 100 *
                                            GetPointIntensity(mz, peakData.MzList, peakData.IntensityList) /
                                            maxObservedIntensity;
                    var intensityDiff = observedIntensity - theoreticalIntensity;
                    fit += intensityDiff * intensityDiff;
                    sum += theoreticalIntensity * theoreticalIntensity;
                    pointsUsed++;
                }
            }

            return(fit / (sum + 0.001));
        }
コード例 #7
0
        // for outputting valid MzXML strings to file
        public string ToXML(FAIMStoMzXMLProcessor processor)
        {
            // place scan byte depth into our tracking list
            var index = new Index(processor.ByteTracking.CurrentScan, processor.ByteTracking.ByteDepth + 2);

            processor.ByteTracking.ScanOffsets.Add(index);

            FilterLine = FixFilterLine();

            var sb = new StringBuilder();

            sb.AppendFormat("  <scan num=\"{0}\"", processor.ByteTracking.CurrentScan).AppendLine();

            sb.AppendFormat("   msLevel=\"{0}\"", MsLevel).AppendLine();
            sb.AppendFormat("   peaksCount=\"{0}\"", PeaksCount).AppendLine();
            sb.AppendFormat("   polarity=\"{0}\"", Polarity).AppendLine();
            sb.AppendFormat("   scanType=\"{0}\"", ScanType).AppendLine();
            sb.AppendFormat("   filterLine=\"{0}\"", FilterLine).AppendLine();
            sb.AppendFormat("   retentionTime=\"{0}\"", RetentionTime).AppendLine();
            sb.AppendFormat("   lowMz=\"" + Math.Round(LowMz, 3) + "\"").AppendLine();
            sb.AppendFormat("   highMz=\"" + Math.Round(HighMz, 3) + "\"").AppendLine();
            sb.AppendFormat("   basePeakMz=\"" + Math.Round(BasePeakMz, 3) + "\"").AppendLine();
            sb.AppendFormat("   basePeakIntensity=\"" + FormatSpecialNumber(BasePeakIntensity) + "\"").AppendLine();
            sb.AppendFormat("   totIonCurrent=\"" + FormatSpecialNumber(TotIonCurrent) + "\">").AppendLine();
            sb.AppendLine(PeakData.ToXML(3));

            // advance the byteTracker for Ms2 Indices
            processor.ByteTracker(sb.ToString(), true);

            processor.ByteTracking.CurrentScan++;

            foreach (var ms2 in Ms2s)
            {
                var ms2String = ms2.ToXML(processor);
                sb.AppendLine(ms2String);

                // advance byteTracker for the Ms2 Entry
                processor.ByteTracker(ms2String);
            }

            sb.Append("  </scan>");
            processor.ByteTracker("  </scan>");

            return(sb.ToString());
        }
コード例 #8
0
        /// <summary>
        ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
        ///     intensity by specified intensity.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="intensityNormalizer">
        ///     intensity to normalize the peaks to. assumes that if peak with intensity = normalizer was
        ///     present, it would be normalized to 100
        /// </param>
        /// <param name="mzDelta">
        ///     specifies the mass delta between theoretical and observed m/z. The we are looking to score
        ///     against the feature in the observed data at theoeretical m/z + mzDelta
        /// </param>
        /// <param name="minIntensityForScore">minimum intensity for score</param>
        /// <param name="debug">prints debugging information if this is set to true.</param>
        public override double FitScore(PeakData peakData, int chargeState, double intensityNormalizer, double mzDelta,
                                        double minIntensityForScore, bool debug = false)
        {
            throw new Exception("Don't Ever come into this FitScore overload in PeakFit");

            var numPoints = TheoreticalDistMzs.Count;

            if (numPoints < 3)
            {
                return(1);
            }

            double fit      = 0;
            double sum      = 0;
            double lastYVal = 0;
            double diff     = 0;

            for (var pointNum = 0; pointNum < numPoints; pointNum++)
            {
                var mz = TheoreticalDistMzs[pointNum] + mzDelta;
                var theoreticalIntensity = TheoreticalDistIntensities[pointNum];

                // observed intensities have to be normalized so that the maximum intensity is 100,
                if (theoreticalIntensity >= minIntensityForScore && diff >= 0 && theoreticalIntensity < lastYVal)
                {
                    ThrashV1Peak foundPeak;
                    var          found = peakData.GetPeak(mz - 0.1, mz + 0.1, out foundPeak);
                    if (found)
                    {
                        var observedIntensity = 100 * foundPeak.Intensity / intensityNormalizer;
                        var intensityDiff     = observedIntensity - theoreticalIntensity;
                        var intensitySum      = observedIntensity + theoreticalIntensity;
                        fit += intensityDiff * intensityDiff;
                        sum += theoreticalIntensity * theoreticalIntensity;
                    }
                    fit += theoreticalIntensity * theoreticalIntensity;
                    sum += theoreticalIntensity * theoreticalIntensity;
                }
                diff     = theoreticalIntensity - lastYVal;
                lastYVal = theoreticalIntensity;
            }

            return(fit / (sum + 0.001));
        }
コード例 #9
0
        /// <summary>
        ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
        ///     intensity by specified intensity.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="intensityNormalizer">
        ///     intensity to normalize the peaks to. assumes that if peak with intensity = normalizer was
        ///     present, it would be normalized to 100
        /// </param>
        /// <param name="mzDelta">
        ///     specifies the mass delta between theoretical and observed m/z. The we are looking to score
        ///     against the feature in the observed data at theoeretical m/z + mzDelta
        /// </param>
        /// <param name="minIntensityForScore">minimum intensity for score</param>
        /// <param name="debug">prints debugging information if this is set to true.</param>
        public override double FitScore(PeakData peakData, int chargeState, double intensityNormalizer, double mzDelta,
                                        double minIntensityForScore, bool debug = false)
        {
            throw new Exception("Don't Ever come into this FitScore overload in PeakFit");

            /*
             * var numPoints = TheoreticalDistMzs.Count;
             * if (numPoints < 3)
             *  return 1;
             *
             * double fit = 0;
             * double sum = 0;
             * double lastYVal = 0;
             * double diff = 0;
             *
             * for (var pointNum = 0; pointNum < numPoints; pointNum++)
             * {
             *  var mz = TheoreticalDistMzs[pointNum] + mzDelta;
             *  var theoreticalIntensity = TheoreticalDistIntensities[pointNum];
             *
             *  // observed intensities have to be normalized so that the maximum intensity is 100,
             *  if (theoreticalIntensity >= minIntensityForScore && diff >= 0 && theoreticalIntensity < lastYVal)
             *  {
             *      clsPeak foundPeak;
             *      var found = peakData.GetPeak(mz - 0.1, mz + 0.1, out foundPeak);
             *      if (found)
             *      {
             *          var observedIntensity = 100 * foundPeak.Intensity / intensityNormalizer;
             *          var intensityDiff = observedIntensity - theoreticalIntensity;
             *          var intensitySum = observedIntensity + theoreticalIntensity;
             *          fit += intensityDiff * intensityDiff;
             *          sum += theoreticalIntensity * theoreticalIntensity;
             *      }
             *      fit += theoreticalIntensity * theoreticalIntensity;
             *      sum += theoreticalIntensity * theoreticalIntensity;
             *  }
             *  diff = theoreticalIntensity - lastYVal;
             *  lastYVal = theoreticalIntensity;
             * }
             *
             * return fit / (sum + 0.001);
             */
        }
コード例 #10
0
        /*[gord]  the following is currently unused. The idea was to give weighting to the algorithm so that
         * the user could favor certain fitting parameters (i.e. space between isotopomers) over others
         * public double FindIsotopicDist(PeakProcessing.PeakData peakData, int cs, PeakProcessing.Peak peak,
         *  IsotopeFitRecord isoRecord, double deleteIntensityThreshold, double spacingWeight, double spacingVar,
         *  double signalToNoiseWeight, double signalToNoiseThresh, double ratioWeight, double ratioThreshold,
         *  double fitWeight, double fitThreshold, bool debug = false)
         * {
         *  if (cs <= 0)
         *  {
         *      Environment.Exit(1);
         *  }
         *
         *  //Get theoretical distribution using Mercury algorithm
         *  double peakMass = (peak.mdbl_mz - ChargeCarrierMass) * cs;
         *  double resolution = peak.mdbl_mz / peak.mdbl_FWHM;
         *  GetIsotopeDistribution(peakMass, cs, resolution, out TheoreticalDistMzs,
         *      out TheoreticalDistIntensities,
         *      deleteIntensityThreshold, debug);
         *
         *  double theorMostAbundantPeakMz = IsotopeDistribution.mdbl_max_peak_mz;
         *  double delta = peak.mdbl_mz - theorMostAbundantPeakMz;
         *  double spacingScore = 0;
         *  double signalToNoiseScore = 0;
         *  double ratioScore = 0;
         *  double totalScore = 0;
         *  double maximumScore = spacingWeight + signalToNoiseWeight + ratioWeight + fitWeight;
         *
         *  //this will select peaks to the left until
         *  for (double dd = 1.003 / cs; dd <= 10.03 / cs; dd += 1.003 / cs)
         *  {
         *      double theorLeftPeakMz = 0;
         *      double theorLeftPeakIntensity = 0;
         *      PeakProcessing.Peak leftPeak;
         *      peakData.FindPeak(peak.mdbl_mz - dd - peak.mdbl_FWHM, peak.mdbl_mz - dd + peak.mdbl_FWHM, out leftPeak);
         *      //PeakProcessing.FindPeak
         *      IsotopeDistribution.FindPeak(theorMostAbundantPeakMz - dd - 0.2 / cs,
         *          theorMostAbundantPeakMz - dd + 0.2 / cs, out theorLeftPeakMz, out theorLeftPeakIntensity);
         *
         *      if (leftPeak.mdbl_mz > 0) //if there is an experimental peak...
         *      {
         *          //get spacing score
         *          spacingScore = spacingWeight * 1;
         *
         *          //get S/N score
         *          if (leftPeak.mdbl_SN > signalToNoiseThresh)
         *          {
         *              signalToNoiseScore = signalToNoiseWeight * 1;
         *          }
         *
         *          //get Ratio score
         *          double leftPeakRatio = leftPeak.mdbl_intensity / peak.mdbl_intensity;
         *          double theorLeftPeakRatio = theorLeftPeakIntensity / 1;
         *          //TODO: need to check if this most abundant theor peak's intensity is 1
         *      }
         *
         *      //get Ratio score
         *  }
         *  //get S/N score
         *  //get Fit score
         *  //calculate maximum score
         *  //get overall score
         *  return 0;
         * }*/

        public PeakData GetTheoreticalIsotopicDistributionPeakList(List <double> xvals, List <double> yvals)
        {
            var peakList  = new PeakData();
            var processor = new PeakProcessor();

            processor.SetOptions(0.5, 1, false, PeakFitType.Apex);
            processor.DiscoverPeaks(xvals, yvals, 0, 10000);

            var numpeaks = processor.PeakData.GetNumPeaks();

            for (var i = 0; i < numpeaks; i++)
            {
                ThrashV1Peak peak;
                processor.PeakData.GetPeak(i, out peak);
                peakList.AddPeak(peak);
            }

            return(peakList);
        }
コード例 #11
0
        /// <summary>
        ///     calculates the fit score for a peak against a molecular formula.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="peak"> peak for which we want to compute the fit function.</param>
        /// <param name="formula">stores the formula we want to fit.</param>
        /// <param name="deleteIntensityThreshold">intensity of least isotope to delete.</param>
        /// <param name="minTheoreticalIntensityForScore">minimum intensity of point to consider for scoring purposes.</param>
        /// <param name="debug">if debugging output is enabled</param>
        public double GetFitScore(PeakData peakData, int chargeState, ThrashV1Peak peak, MolecularFormula formula,
                                  double deleteIntensityThreshold, double minTheoreticalIntensityForScore, bool debug = false)
        {
            if (chargeState <= 0)
            {
                Console.WriteLine("Negative value for charge state. " + chargeState);
                Environment.Exit(1);
            }
            if (debug)
            {
                Console.WriteLine("Getting isotope distribution for formula = " + formula + " mz = " + peak.Mz +
                                  " charge = " + chargeState);
            }

            var resolution = peak.Mz / peak.FWHM;

            IsotopeDistribution.ChargeCarrierMass = ChargeCarrierMass;
            IsotopeDistribution.ApType            = ApodizationType.Gaussian;

            TheoreticalDistIntensities.Clear();
            TheoreticalDistMzs.Clear();

            IsotopeDistribution.CalculateDistribution(chargeState, resolution, formula, out TheoreticalDistMzs,
                                                      out TheoreticalDistIntensities, deleteIntensityThreshold, out IsotopeMzs, out IsotopeIntensities, debug);

            var delta = peak.Mz - IsotopeDistribution.MaxPeakMz;

            if (debug)
            {
                Console.WriteLine("Going for first fit");
            }

            int pointsUsed;

            return(FitScore(peakData, chargeState, peak, delta, minTheoreticalIntensityForScore, out pointsUsed,
                            debug));
        }
コード例 #12
0
 /// <summary>
 ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
 ///     intensity by specified intensity.
 /// </summary>
 /// <param name="peakData"> variable which stores the data itself</param>
 /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
 /// <param name="peak"> peak for which we want to compute the fit function.</param>
 /// <param name="mzDelta">specifies the mass delta between theoretical and observed m/z with the best fit so far.</param>
 /// <param name="minIntensityForScore">minimum intensity for score</param>
 /// <param name="pointsUsed">number of points used</param>
 /// <param name="debug">debug output flag</param>
 public abstract double FitScore(PeakData peakData, int chargeState, ThrashV1Peak peak, double mzDelta,
                                 double minIntensityForScore, out int pointsUsed, bool debug = false);
コード例 #13
0
        /// <summary>
        ///     will calculate the delta mz (referenced to the theor) based on several of the observed peaks
        /// </summary>
        /// <param name="startingDelta"></param>
        /// <param name="peakWidth"></param>
        /// <param name="obsPeakData"></param>
        /// <param name="theorPeakData"></param>
        /// <param name="theorIntensityCutOff"></param>
        /// <returns></returns>
        public double CalculateDeltaFromSeveralObservedPeaks(double startingDelta, double peakWidth,
                                                             PeakData obsPeakData, PeakData theorPeakData, double theorIntensityCutOff)
        {
            //the idea is to use a selected number of theor peaks
            //and for each theor peak,  use the delta (mz offset) info
            //to find the obs peak data and determine the delta value for that peak.
            //accumulate delta values in an array and then calculate a weighted average

            var numTheorPeaks         = theorPeakData.GetNumPeaks();
            var filteredTheorPeakData = new PeakData();

            //filter the theor list
            var numFilteredTheorPeaks = 0;

            for (var i = 0; i < numTheorPeaks; i++)
            {
                ThrashV1Peak peak;
                theorPeakData.GetPeak(i, out peak);

                if (peak.Intensity >= theorIntensityCutOff)
                {
                    filteredTheorPeakData.AddPeak(peak);
                    numFilteredTheorPeaks++;
                }
            }

            if (numFilteredTheorPeaks == 0)
            {
                return(startingDelta);
            }

            var    deltaArray     = new double[numFilteredTheorPeaks];
            var    intensityArray = new double[numFilteredTheorPeaks];
            double intensitySum   = 0;

            //double weightedSumOfDeltas = 0;

            for (var i = 0; i < numFilteredTheorPeaks; i++)
            {
                ThrashV1Peak theorPeak;
                filteredTheorPeakData.GetPeak(i, out theorPeak);

                var targetMzLower = theorPeak.Mz + startingDelta - peakWidth;
                var targetMzUpper = theorPeak.Mz + startingDelta + peakWidth;

                ThrashV1Peak foundPeak;
                obsPeakData.FindPeak(targetMzLower, targetMzUpper, out foundPeak);

                if (foundPeak.Mz > 0)
                {
                    deltaArray[i]     = foundPeak.Mz - theorPeak.Mz;
                    intensityArray[i] = foundPeak.Intensity;
                    intensitySum     += foundPeak.Intensity;
                }
                else
                {
                    deltaArray[i]     = startingDelta;
                    intensityArray[i] = 0;
                    //obs peak was not found; therefore assign 0 intensity (will have no effect on delta calc)
                }
            }

            if (intensitySum.Equals(0))
            {
                return(startingDelta); // no obs peaks found at all;  return default
            }
            //now perform a weighted average
            double weightedDelta = 0;

            for (var i = 0; i < numFilteredTheorPeaks; i++)
            {
                weightedDelta += intensityArray[i] / intensitySum * deltaArray[i];
            }

            return(weightedDelta);
        }
コード例 #14
0
        /// <summary>
        ///     calculates the fit score for a peak.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="peak"> peak for which we want to compute the fit function.</param>
        /// <param name="isoRecord">stores the result of the fit.</param>
        /// <param name="deleteIntensityThreshold">intensity of least isotope to delete.</param>
        /// <param name="minTheoreticalIntensityForScore">minimum intensity of point to consider for scoring purposes.</param>
        /// <param name="leftFitStringencyFactor"></param>
        /// <param name="rightFitStringencyFactor"></param>
        /// <param name="pointsUsed">Number of points used</param>
        /// <param name="debug">enable debugging output</param>
        /// <remarks>
        ///     This fitter is used by MassTransform.cpp.   It does more than just get a fit score. It first
        ///     gets a fit score and then slides to the left until the fit score does not improve and then resets
        ///     to the center point and then slides to the right until the fit score does not improve. Returns the
        ///     best fit score and fills the isotopic profile (isotopeFitRecord)
        /// </remarks>
        public double GetFitScore(PeakData peakData, int chargeState, ref ThrashV1Peak peak,
                                  out HornTransformResults isoRecord, double deleteIntensityThreshold, double minTheoreticalIntensityForScore,
                                  double leftFitStringencyFactor, double rightFitStringencyFactor, out int pointsUsed, bool debug = false)
        {
            isoRecord = new HornTransformResults();
            if (chargeState <= 0)
            {
                Console.WriteLine("Negative value for charge state. " + chargeState);
                Environment.Exit(1);
            }
            //initialize
            var peakMass = (peak.Mz - ChargeCarrierMass) * chargeState;

            // by now the cc_mass, tag formula and media options in Mercury(Isotope generation)
            // should be set.
            if (debug)
            {
                Console.WriteLine("\n\n-------------------- BEGIN TRANSFORM ---------------------------" + chargeState);
                Console.WriteLine("Getting isotope distribution for mass = " + peakMass + " mz = " + peak.Mz +
                                  " charge = " + chargeState);
            }
            var resolution = peak.Mz / peak.FWHM;

            // DJ Jan 07 2007: Need to get all peaks down to delete interval so that range of deletion is correct.
            //GetIsotopeDistribution(peakMass, chargeState, resolution, TheoreticalDistMzs, TheoreticalDistIntensities,
            //  deleteIntensityThreshold, debug);
            GetIsotopeDistribution(peakMass, chargeState, resolution, out TheoreticalDistMzs,
                                   out TheoreticalDistIntensities, deleteIntensityThreshold, debug);
            var theorPeakData = GetTheoreticalIsotopicDistributionPeakList(TheoreticalDistMzs,
                                                                           TheoreticalDistIntensities);
            var numpeaks = theorPeakData.GetNumPeaks();

            if (debug)
            {
                Console.WriteLine("---------------------------------------- THEORETICAL PEAKS ------------------");
                Console.WriteLine("Theoretical peak\t" + "Index\t" + "MZ\t" + "Intensity\t" + "FWHM\t" + "SigNoise");
                for (var i = 0; i < numpeaks; i++)
                {
                    ThrashV1Peak theorpeak;
                    theorPeakData.GetPeak(i, out theorpeak);
                    Console.WriteLine("Theoretical peak\t" + i + "\t" + theorpeak.Mz + "\t" +
                                      theorpeak.Intensity + "\t" + theorpeak.FWHM + "\t" + theorpeak.SignalToNoiseDbl);
                }
                Console.WriteLine("----------------------------------- END THEORETICAL PEAKS ------------------");
            }

            // Anoop April 9 2007: For checking if the distribution does not overlap/link with any other distribution
            // Beginnings of deisotoping correction
            //bool is_linked = false;
            //is_linked =  IsIsotopeLinkedDistribution(deleteIntensityThreshold);
            var delta = peak.Mz - IsotopeDistribution.MaxPeakMz;

            //if(debug)
            //  System.Console.WriteLine("Going for first fit");
            var fit = FitScore(peakData, chargeState, peak, delta, minTheoreticalIntensityForScore, out pointsUsed,
                               debug);

            if (debug)
            {
                Console.WriteLine("Peak\tPeakIdx\tmz\tintens\tSN\tFWHM\tfit\tdelta");
                Console.WriteLine("CENTER\t" + peak.PeakIndex + "\t" + peak.Mz + "\t" + peak.Intensity +
                                  "\t" + peak.SignalToNoiseDbl + "\t" + peak.FWHM + "\t" + fit + "\t" + delta + "\t");
            }

            if (!UseThrash)
            {
                isoRecord.Fit           = fit;
                isoRecord.FitCountBasis = pointsUsed;
                isoRecord.Mz            = peak.Mz;
                isoRecord.AverageMw     = IsotopeDistribution.AverageMw + delta * chargeState;
                isoRecord.MonoMw        = IsotopeDistribution.MonoMw + delta * chargeState;
                isoRecord.MostIntenseMw = IsotopeDistribution.MostIntenseMw + delta * chargeState;
                isoRecord.DeltaMz       = delta;
                return(fit);
            }

            double p1Fit = -1, m1Fit = -1; // [gord]: this seems unused
            var    mPeak    = IsotopeDistribution.MaxPeakMz;
            var    nextPeak = new ThrashV1Peak();

            var bestFit           = fit;
            var bestFitCountBasis = pointsUsed;
            var bestDelta         = delta;
            //double maxY = peak.mdbl_intensity;

            var fitCountBasis = 0;

            //------------- Slide to the LEFT --------------------------------------------------
            for (var dd = 1.003 / chargeState; dd <= 10.03 / chargeState; dd += 1.003 / chargeState)
            {
                double mzLeft;
                double intensityLeft;

                //check for theoretical peak to the right of TheoreticalMaxPeak; store mz and intensity
                var foundPeak = FindPeak(mPeak + dd - 0.2 / chargeState, mPeak + dd + 0.2 / chargeState, out mzLeft,
                                         out intensityLeft,
                                         debug);

                // if the above theoretical peak was found,  look one peak to the LEFT in the Experimental peaklist
                if (foundPeak)
                {
                    peakData.FindPeak(peak.Mz - dd - peak.FWHM, peak.Mz - dd + peak.FWHM,
                                      out nextPeak);
                }

                if (mzLeft > 0 && nextPeak.Mz > 0)
                //if there is a theoreticalPeak to the RIGHT of theoreticalMaxPeak AND there is an experimentalPeak to the LEFT of experimentalMaxPeak...
                {
                    delta = peak.Mz - mzLeft;
                    // essentially, this shifts the theoretical over to the left and gets the delta; then check the fit
                    var currentPeakCopy = new ThrashV1Peak(peak); // in c++ this copy is created by value;
                    currentPeakCopy.Intensity = nextPeak.Intensity;
                    fit = FitScore(peakData, chargeState, currentPeakCopy, delta, minTheoreticalIntensityForScore,
                                   out fitCountBasis, debug);
                    if (debug)
                    {
                        //System.Console.WriteLine(" isotopes. Fit =" + fit + " Charge = " + cs + " Intensity = " + nxt_peak.mdbl_intensity + " delta = " + delta);
                        Console.WriteLine("LEFT\t" + nextPeak.PeakIndex + "\t" + nextPeak.Mz + "\t" +
                                          nextPeak.Intensity + "\t" + nextPeak.SignalToNoiseDbl + "\t" + nextPeak.FWHM +
                                          "\t" + fit + "\t" + delta);
                    }
                }
                else
                {
                    if (debug)
                    {
                        Console.WriteLine("LEFT\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 +
                                          "\t" + -1);
                    }
                    fit = bestFit + 1000; // make the fit terrible
                }
                // TODO: Currently, if fit score is less than best_fit, iteration stops.  Future versions should continue attempted fitting if fit was within a specified range of the best fit
                // 26th February 2007 Deep Jaitly

                /*if (fit <= bestFit)
                 * {
                 *  if (nextPeak.mdbl_intensity > peak.mdbl_intensity)
                 *      peak.mdbl_intensity = nextPeak.mdbl_intensity;
                 *  maxY = peak.mdbl_intensity;
                 *  bestFit = fit;
                 *  bestDelta = delta;
                 * }*/
                var leftFitFactor = fit / bestFit;
                if (leftFitFactor <= leftFitStringencyFactor)
                {
                    if (nextPeak.Intensity > peak.Intensity)
                    {
                        peak.Intensity = nextPeak.Intensity;
                    }
                    //maxY = peak.mdbl_intensity;
                    bestFit           = fit;
                    bestFitCountBasis = fitCountBasis;
                    bestDelta         = delta;
                }
                else
                {
                    if (p1Fit.Equals(-1)) //[gord]   what is this doing?  Peak1 fit??
                    {
                        p1Fit = fit;
                    }
                    if (!CompleteFitThrash)
                    {
                        break;
                    }
                }
            }

            //if (debug)
            //      System.Console.WriteLine("\n---------------- Sliding to the RIGHT -------------------------";
            for (var dd = 1.003 / chargeState; dd <= 10.03 / chargeState; dd += 1.003 / chargeState)
            {
                double mzRight;
                double intensityRight;
                ////check for theoretical peak to the LEFT of TheoreticalMaxPeak; store mz and intensity
                var foundPeak = FindPeak(mPeak - dd - 0.2 / chargeState, mPeak - dd + 0.2 / chargeState, out mzRight,
                                         out intensityRight,
                                         debug);

                // if the above theoretical peak was found,  look one peak to the RIGHT in the Experimental peaklist
                if (foundPeak)
                {
                    peakData.FindPeak(peak.Mz + dd - peak.FWHM, peak.Mz + dd + peak.FWHM,
                                      out nextPeak);
                }

                if (mzRight > 0 && nextPeak.Mz > 0)
                {
                    delta = peak.Mz - mzRight;
                    var currentPeakCopy = new ThrashV1Peak(peak);
                    currentPeakCopy.Intensity = nextPeak.Intensity;
                    fit = FitScore(peakData, chargeState, currentPeakCopy, delta, minTheoreticalIntensityForScore,
                                   out fitCountBasis, debug);
                    //fit = FitScore(pk_data, cs, nxt_peak.mdbl_intensity, delta);
                    if (debug)
                    {
                        //System.Console.WriteLine(" isotopes. Fit =" + fit + " Charge = " + chargeState + " Intensity = " + nextPeak.mdbl_intensity + " delta = " + delta);
                        Console.WriteLine("RIGHT\t" + nextPeak.PeakIndex + "\t" + nextPeak.Mz + "\t" +
                                          nextPeak.Intensity + "\t" + nextPeak.SignalToNoiseDbl + "\t" + nextPeak.FWHM +
                                          "\t" + fit + "\t" + delta);
                    }
                }
                else
                {
                    fit = bestFit + 1000; //force it to be a bad fit
                    if (debug)
                    {
                        //  System.Console.WriteLine("No peak found");
                        Console.WriteLine("RIGHT\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 + "\t" + -1 +
                                          "\t" + -1);
                    }
                }

                /*if (fit <= bestFit)
                 * {
                 * if (nextPeak.mdbl_intensity > peak.mdbl_intensity)
                 * peak.mdbl_intensity = nextPeak.mdbl_intensity;
                 * MaxY = peak.mdbl_intensity;
                 * bestFit = fit;
                 * bestDelta = delta;
                 * }*/
                var rightFitFactor = fit / bestFit;
                if (rightFitFactor <= rightFitStringencyFactor)
                {
                    if (nextPeak.Intensity > peak.Intensity)
                    {
                        peak.Intensity = nextPeak.Intensity;
                    }
                    //maxY = peak.mdbl_intensity;
                    bestFit           = fit;
                    bestFitCountBasis = fitCountBasis;
                    bestDelta         = delta;
                }
                else
                {
                    if (m1Fit.Equals(-1))
                    {
                        m1Fit = fit;
                    }
                    if (!CompleteFitThrash)
                    {
                        break;
                    }
                }
            }

            //double theorIntensityCutoff = 30; //
            //double peakWidth = peak.mdbl_FWHM;
            if (debug)
            {
                Console.WriteLine("Std delta = \t" + bestDelta);
            }
            //best_delta = CalculateDeltaFromSeveralObservedPeaks(best_delta, peakWidth, pk_data, theorPeakData, theorIntensityCutoff);
            if (debug)
            {
                Console.WriteLine("Weighted delta = \t" + bestDelta);
            }

            isoRecord.Fit           = bestFit;
            isoRecord.FitCountBasis = bestFitCountBasis;
            isoRecord.ChargeState   = chargeState;
            isoRecord.Mz            = peak.Mz;
            isoRecord.DeltaMz       = bestDelta;
            isoRecord.AverageMw     = IsotopeDistribution.AverageMw + bestDelta * chargeState;
            isoRecord.MonoMw        = IsotopeDistribution.MonoMw + bestDelta * chargeState;
            isoRecord.MostIntenseMw = IsotopeDistribution.MostIntenseMw + bestDelta * chargeState;

            //iso_record.mbln_flag_isotope_link = is_linked;
            pointsUsed = bestFitCountBasis;
            return(bestFit);
        }
コード例 #15
0
 /// <summary>
 ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
 ///     intensity by specified intensity.
 /// </summary>
 /// <param name="peakData"> variable which stores the data itself</param>
 /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
 /// <param name="normalizer">
 ///     intensity to normalize the peaks to. assumes that if peak with intensity = normalizer was
 ///     present, it would be normalized to 100
 /// </param>
 /// <param name="mzDelta">
 ///     specifies the mass delta between theoretical and observed m/z. The we are looking to score
 ///     against the feature in the observed data at theoeretical m/z + mz_delta
 /// </param>
 /// <param name="minIntensityForScore">minimum intensity for score</param>
 /// <param name="debug">prints debugging information if this is set to true.</param>
 public abstract double FitScore(PeakData peakData, int chargeState, double normalizer, double mzDelta,
                                 double minIntensityForScore, bool debug = false);
コード例 #16
0
        static void Main(string[] args)
        {
            // *** CHANGE TO THE IP ADDRESS FOR INSTRUMENT ***
            string instrumentIpAddress = "192.168.86.70";

            // Create a TCP client for communicating with the Hyperion instrument
            TcpClient tcpClient = new TcpClient();

            // Connect to the instrument over TCP/IP

            tcpClient.Connect(instrumentIpAddress, Command.TcpPort);
            NetworkStream tcpNetworkStream = tcpClient.GetStream();


            // Execute a simple command to retrieve the instrument serial number
            CommandResponse response = Command.Execute(
                tcpNetworkStream,
                CommandName.GetSerialNumber);

            // The response (unless specifically suppressed) contains an ASCII based Message field
            // AND a binary (byte[]) Content field. The ASCII field is intended to be human readable
            // and the binary data is intended to be easily parsed by a computer.
            WriteLine("Instrument Serial Number");
            WriteLine("------------------------");
            WriteLine($"Message: {response.Message}");
            WriteLine($"Content Converted to String {response.AsString()}");

            WriteLine();
            WriteLine();

            // Execute the #GetPeaks command. The CommandName contains static string members
            // for commands exposed by the instrument.
            response = Command.Execute(
                tcpNetworkStream,
                CommandName.GetPeaks);

            // Several extension methods are defined in the communication library that
            // easily convert the response from a byte[] to useful types such as
            // int, double, and more complex responses such as Peak/Spectrum data
            PeakData peakData = response.AsPeakData();

            WriteLine("Peak Data Header");
            WriteLine("---------------------");

            WriteLine($"Serial Number: {peakData.SerialNumber}");
            WriteLine($"Timestamp: {peakData.Timestamp}");

            WriteLine();

            WriteLine("Peaks");
            WriteLine("-----");

            // The PeakData exposes the peaks in two ways...as Arrays and as Enumerables. The
            // arrays will allocate new memory for the data but can be advantageous if the
            // data needs to be repeatedly accessed. The Enumerable is great for situations where
            // the data needs to be simply iterated through once and processed. This provides very
            // high performance and low overhead for situations such as streaming large number of
            // peaks at very high speeds.
            for (int channelIndex = 0; channelIndex < 4; channelIndex++)
            {
                WriteLine($"Channel {channelIndex}: ");

                foreach (double wavelength in peakData.AsEnumerable(1))
                {
                    WriteLine($"\t{wavelength} nm");
                }
            }

            WriteLine();
            WriteLine();



            // Retrieve the optical full spectrum response
            response = Command.Execute(tcpNetworkStream, CommandOptions.None, CommandName.GetSpectrum);

            // Use the extension methods to easily obtain the spectrum data
            SpectrumData spectrumData = response.AsSpectrumData();

            WriteLine("Full Spectrum");
            WriteLine("-------------");
            WriteLine($"Wavelength Start: {spectrumData.WavelengthStart:F3} nm");
            WriteLine($"Wavelength Step: {(int)(1000 * spectrumData.WavelengthStep)} pm");
            WriteLine($"Wavelength Step Count: {spectrumData.WavelengthStepCount}");
            WriteLine($"Channel Count: {spectrumData.ChannelCount}");
            WriteLine($"Serial Number: {spectrumData.SerialNumber}");
            WriteLine($"Timestamp: {spectrumData.Timestamp}");

            WriteLine();
            WriteLine();

            // Remove existing sensors
            response = Command.Execute(tcpNetworkStream, CommandOptions.None, CommandName.GetSensorNames);
            string[] sensorNames = response.AsString().Split(' ');
            foreach (string sensorName in sensorNames)
            {
                WriteLine($"Removing sensor: {sensorName}");
                response = Command.Execute(tcpNetworkStream, CommandOptions.None, CommandName.RemoveSensor, sensorName);
            }

            // Add some sensors
            for (int i = 1; i <= 20; i++)
            {
                string name             = $"sensor_{i}";
                string model            = i % 2 == 1 ? "os7510" : "os7520";
                int    channel          = (i - 1) % 4 + 1;
                int    wavelength       = 1510 + ((i - 1) % 4) * 20;
                bool   fixedOrientation = i % 2 == 0;
                double calibration      = 10.0 * i;
                WriteLine($"Adding Sensor {name}");
                WriteLine("----------------------------------------");
                WriteLine($"Model: {model}");
                WriteLine($"Channel: {channel}");
                WriteLine($"Wavelength Band: {wavelength} nm");
                WriteLine($"Calibration Factor: {calibration} nm/g");
                WriteLine($"Fixed Orientation: {fixedOrientation}");
                WriteLine();
                string[] input_args = { name,
                                        model,
                                        channel.ToString(),
                                        "0",
                                        wavelength.ToString(),
                                        calibration.ToString(),
                                        fixedOrientation.ToString() };
                response = Command.Execute(tcpNetworkStream, CommandOptions.None, CommandName.AddSensor, input_args);
            }

            // Retrieve the defined Sensors
            response = Command.Execute(tcpNetworkStream, CommandOptions.None, CommandName.ExportSensors);

            WriteLine(response.Message);

            int offset = 0;

            int version = BitConverter.ToUInt16(response.Content, offset);

            offset += sizeof(UInt16);

            int numberOfSensors = BitConverter.ToUInt16(response.Content, offset);

            offset += sizeof(UInt16);

            // Sensor Count
            WriteLine($"Sensors - {numberOfSensors} (Data Export Version = {version})");
            WriteLine();

            // Create sensors

            for (int sensorIndex = 0; sensorIndex < numberOfSensors; sensorIndex++)
            {
                FabryPerotAccelerometer fpSensor = (FabryPerotAccelerometer)SensorBase.Create(response.Content, ref offset);
                WriteLine($"Sensor {sensorIndex + 1} - {fpSensor.Name} ({fpSensor.Model})");
                WriteLine($"Sensor Definition Version: {fpSensor.FPSesnorVersion}");
                WriteLine("----------------------------------------");
                WriteLine($"ID: {fpSensor.Id}");
                WriteLine($"Model: {fpSensor.Model}");
                WriteLine($"Channel: {fpSensor.DutChannelIndex + 1}");
                WriteLine($"Wavelength Band: {fpSensor.WavelengthBand} nm");
                WriteLine($"Calibration Factor: {fpSensor.CalibrationFactor} nm/g");
                WriteLine($"Fixed Orientation: {fpSensor.FixedOrientation}");
                WriteLine();
            }

            WriteLine();



            // Cleanup by closing the TCP connection
            tcpNetworkStream.Close();
            tcpClient.Close();



            // Now demonstrating using the data streaming to continuously read consecutive
            // peak data sets.
            tcpClient = new TcpClient();
            tcpClient.Connect(instrumentIpAddress, StreamingDataReader.PeakTcpPort);
            tcpNetworkStream = tcpClient.GetStream();

            // The StreamingDataReader class works for peaks and full spectrum. It can be
            // used to easily and efficiently read consecutive datasets. The class internally
            // uses a single buffer of memory to avoid allocating and collecting large
            // amounts of memory and system resources. The mode Peak, Spectrum, Sensor) is
            // defined when the reader is created.
            StreamingDataReader reader = new StreamingDataReader(StreamingDataMode.Peaks);

            WriteLine("Streaming Peak Data Acquistion Serial Numbers");
            WriteLine("---------------------------------------------");

            for (int index = 0; index < 10; index++)
            {
                WriteLine(
                    $"{index}: " +
                    $"{ reader.ReadStreamingData(tcpNetworkStream).AsPeakData().SerialNumber}");
            }

            WriteLine();

            tcpNetworkStream.Close();
            tcpClient.Close();



            // Now demonstrating using the data streaming to continuously read consecutive
            // sensor data sets.
            tcpClient = new TcpClient();
            tcpClient.Connect(instrumentIpAddress, StreamingDataReader.SensorTcpPort);
            tcpNetworkStream = tcpClient.GetStream();

            // The StreamingDataReader class works for peaks, full spectrum and sensors. It can be
            // used to easily and efficiently read consecutive datasets. The class internally
            // uses a single buffer of memory to avoid allocating and collecting large
            // amounts of memory and system resources. The mode Peak, Spectrum, Sensor) is
            // defined when the reader is created.
            StreamingDataReader sensorReader = new StreamingDataReader(StreamingDataMode.Sensor);

            WriteLine("Streaming Sensor Data Acquistion Serial Numbers");
            WriteLine("---------------------------------------------");

            for (int index = 0; index < 10; index++)
            {
                SensorData sensorData = sensorReader.ReadStreamingData(tcpNetworkStream).AsSensorData();

                WriteLine(
                    $"{index}: " +
                    $"{sensorData.SerialNumber}");
            }

            WriteLine();

            tcpNetworkStream.Close();
            tcpClient.Close();



            // Wait for any key press to exit
            ReadLine();
        }
コード例 #17
0
        private void SetIsotopeDistributionToZero(PeakData peakData, ThrashV1Peak peak, double zeroingStartMz,
                                                  double zeroingStopMz, double monoMw, int chargeState, bool clearSpectrum, HornTransformResults record,
                                                  bool debug = false)
        {
            var peakIndices = new List <int>();

            peakIndices.Add(peak.PeakIndex);
            var mzDelta = record.DeltaMz;

            if (debug)
            {
                Console.Error.WriteLine("Clearing peak data for " + peak.Mz + " Delta = " + mzDelta);
                Console.Error.WriteLine("Zeroing range = " + zeroingStartMz + " to " + zeroingStopMz);
            }

            double maxMz = 0;

            if (IsO16O18Data)
            {
                maxMz = (monoMw + 3.5) / chargeState + ChargeCarrierMass;
            }

            var numUnprocessedPeaks = peakData.GetNumUnprocessedPeaks();

            if (numUnprocessedPeaks == 0)
            {
                record.IsotopePeakIndices.Add(peak.PeakIndex);
                return;
            }

            if (clearSpectrum)
            {
                if (debug)
                {
                    Console.Error.WriteLine("Deleting main peak :" + peak.Mz);
                }
                SetPeakToZero(peak.DataIndex, ref peakData.IntensityList, ref peakData.MzList, debug);
            }

            peakData.RemovePeaks(peak.Mz - peak.FWHM, peak.Mz + peak.FWHM, debug);

            if (1 / (peak.FWHM * chargeState) < 3) // gord:  ??
            {
                record.IsotopePeakIndices.Add(peak.PeakIndex);
                peakData.RemovePeaks(zeroingStartMz, zeroingStopMz, debug);
                return;
            }

            // Delete isotopes of mzs higher than mz of starting isotope
            for (var peakMz = peak.Mz + 1.003 / chargeState;
                 (!IsO16O18Data || peakMz <= maxMz) && peakMz <= zeroingStopMz + 2 * peak.FWHM;
                 peakMz += 1.003 / chargeState)
            {
                if (debug)
                {
                    Console.Error.WriteLine("\tFinding next peak top from " + (peakMz - 2 * peak.FWHM) + " to " +
                                            (peakMz + 2 * peak.FWHM) + " pk = " + peakMz + " FWHM = " + peak.FWHM);
                }
                ThrashV1Peak nextPeak;
                peakData.GetPeakFromAll(peakMz - 2 * peak.FWHM, peakMz + 2 * peak.FWHM, out nextPeak);

                if (nextPeak.Mz.Equals(0))
                {
                    if (debug)
                    {
                        Console.Error.WriteLine("\t\tNo peak found.");
                    }
                    break;
                }
                if (debug)
                {
                    Console.Error.WriteLine("\t\tFound peak to delete =" + nextPeak.Mz);
                }

                // Before assuming that the next peak is indeed an isotope, we must check for the height of this
                // isotope. If the height is greater than expected by a factor of 3, lets not delete it.
                peakIndices.Add(nextPeak.PeakIndex);
                SetPeakToZero(nextPeak.DataIndex, ref peakData.IntensityList, ref peakData.MzList, debug);

                peakData.RemovePeaks(nextPeak.Mz - peak.FWHM, nextPeak.Mz + peak.FWHM, debug);
                peakMz = nextPeak.Mz;
            }

            // Delete isotopes of mzs lower than mz of starting isotope
            // TODO: Use the delta m/z to make sure to remove 1- peaks from the unprocessed list, but not from the list of peaks?
            for (var peakMz = peak.Mz - 1.003 / chargeState;
                 peakMz > zeroingStartMz - 2 * peak.FWHM;
                 peakMz -= 1.003 / chargeState)
            {
                if (debug)
                {
                    Console.Error.WriteLine("\tFinding previous peak top from " + (peakMz - 2 * peak.FWHM) + " to " +
                                            (peakMz + 2 * peak.FWHM) + " pk = " + peakMz + " FWHM = " + peak.FWHM);
                }
                ThrashV1Peak nextPeak;
                peakData.GetPeakFromAll(peakMz - 2 * peak.FWHM, peakMz + 2 * peak.FWHM, out nextPeak);
                if (nextPeak.Mz.Equals(0))
                {
                    if (debug)
                    {
                        Console.Error.WriteLine("\t\tNo peak found.");
                    }
                    break;
                }
                if (debug)
                {
                    Console.Error.WriteLine("\t\tFound peak to delete =" + nextPeak.Mz);
                }
                peakIndices.Add(nextPeak.PeakIndex);
                SetPeakToZero(nextPeak.DataIndex, ref peakData.IntensityList, ref peakData.MzList, debug);
                peakData.RemovePeaks(nextPeak.Mz - peak.FWHM, nextPeak.Mz + peak.FWHM, debug);
                peakMz = nextPeak.Mz;
            }

            if (debug)
            {
                Console.Error.WriteLine("Done Clearing peak data for " + peak.Mz);
            }

            peakIndices.Sort();
            // now insert into array.
            var numPeaksObserved       = peakIndices.Count;
            var numIsotopesObserved    = 0;
            var lastIsotopeNumObserved = int.MinValue;

            for (var i = 0; i < numPeaksObserved; i++)
            {
                var currentIndex = peakIndices[i];
                var currentPeak  = new ThrashV1Peak(peakData.PeakTops[currentIndex]);
                var isotopeNum   = (int)(Math.Abs((currentPeak.Mz - peak.Mz) * chargeState / 1.003) + 0.5);
                if (currentPeak.Mz < peak.Mz)
                {
                    isotopeNum = -1 * isotopeNum;
                }
                if (isotopeNum > lastIsotopeNumObserved)
                {
                    lastIsotopeNumObserved = isotopeNum;
                    numIsotopesObserved++;
                    if (numIsotopesObserved > MaxIsotopes)
                    {
                        break;
                    }
                    record.IsotopePeakIndices.Add(peakIndices[i]);
                }
                else
                {
                    record.IsotopePeakIndices[numIsotopesObserved - 1] = peakIndices[i];
                }
            }
            if (debug)
            {
                Console.Error.WriteLine("Copied " + record.NumIsotopesObserved + " isotope peak indices into record ");
            }
        }
コード例 #18
0
        protected virtual bool FindTransform(PeakData peakData, ref ThrashV1Peak peak, out HornTransformResults record,
                                             double backgroundIntensity = 0)
        {
            SetIsotopeFitScorerOptions();
            record = new HornTransformResults();
            if (peak.SignalToNoiseDbl < MinSignalToNoise || peak.FWHM.Equals(0))
            {
                return(false);
            }

            //var resolution = peak.Mz / peak.FWHM;
            /**/
            var chargeState = AutoCorrelationChargeDetermination.GetChargeState(peak, peakData, ShowTraceMessages);

            /*/
             * // This chunk of code tries to use the DeconTools Patterson Algorithm Charge State Calculator, but it gets vastly different results.
             * var xyData = new XYData();
             * var mzArray = peakData.MzList.ToArray();
             * var intensityArray = peakData.IntensityList.ToArray();
             * xyData.SetXYValues(ref mzArray, ref intensityArray);
             * var peakList = new List<Peak>();
             * for (int i = 0; i < peakData.MzList.Count; i++)
             * {
             *  peakList.Add(new Peak(peakData.MzList[i], (float)peakData.IntensityList[i], 1));
             * }
             * var chargeState = DeconTools.Backend.Algorithms.ChargeStateDetermination.PattersonAlgorithm.PattersonChargeStateCalculator.GetChargeState(xyData, peakList, convertDeconPeakToMSPeak(peak));
             * /**/

            if (chargeState == -1 && CheckPatternsAgainstChargeOne)
            {
                chargeState = 1;
            }

            if (ShowTraceMessages)
            {
                Console.Error.WriteLine("Deisotoping :" + peak.Mz);
                Console.Error.WriteLine("Charge = " + chargeState);
            }

            if (chargeState == -1)
            {
                return(false);
            }

            if ((peak.Mz + ChargeCarrierMass) * chargeState > MaxMWAllowed)
            {
                return(false);
            }

            if (IsO16O18Data)
            {
                if (peak.FWHM < 1.0 / chargeState)
                {
                    // move back by 4 Da and see if there is a peak.
                    var          minMz = peak.Mz - 4.0 / chargeState - peak.FWHM;
                    var          maxMz = peak.Mz - 4.0 / chargeState + peak.FWHM;
                    ThrashV1Peak o16Peak;
                    var          found = peakData.GetPeak(minMz, maxMz, out o16Peak);
                    if (found && !o16Peak.Mz.Equals(peak.Mz))
                    {
                        // put back the current into the to be processed list of peaks.
                        peakData.AddPeakToProcessingList(peak);
                        // reset peak to the right peak so that the calling function may
                        // know that the peak might have changed in the O16/O18 business
                        peak = o16Peak;
                        peakData.RemovePeak(peak);
                        return(FindTransform(peakData, ref peak, out record, backgroundIntensity));
                    }
                }
            }

            var peakCharge1 = new ThrashV1Peak(peak);

            // Until now, we have been using constant theoretical delete intensity threshold..
            // instead, from now, we should use one that is proportional to intensity, for more intense peaks.
            // However this will not solve all problems. If thrashing occurs, then the peak intensity will
            // change when the function returns and we may not delete far enough.
            //double deleteThreshold = backgroundIntensity / peak.Intensity * 100;
            //if (backgroundIntensity ==0 || deleteThreshold > _deleteIntensityThreshold)
            //  deleteThreshold = _deleteIntensityThreshold;
            var deleteThreshold = DeleteIntensityThreshold;
            int fitCountBasis;
            var bestFit = _isotopeFitScorer.GetFitScore(peakData, chargeState, ref peak, out record, deleteThreshold,
                                                        MinIntensityForScore, LeftFitStringencyFactor, RightFitStringencyFactor, out fitCountBasis,
                                                        ShowTraceMessages);

            // When deleting an isotopic profile, this value is set to the first m/z to perform deletion at.
            double zeroingStartMz;
            // When deleting an isotopic profile, this value is set to the last m/z to perform deletion at.
            double zeroingStopMz;

            _isotopeFitScorer.GetZeroingMassRange(out zeroingStartMz, out zeroingStopMz, record.DeltaMz, deleteThreshold,
                                                  ShowTraceMessages);
            //bestFit = _isotopeFitter.GetFitScore(peakData, chargeState, peak, record, _deleteIntensityThreshold, _minTheoreticalIntensityForScore, DebugFlag);
            //_isotopeFitter.GetZeroingMassRange(_zeroingStartMz, _zeroingStopMz, record.DeltaMz, _deleteIntensityThreshold, DebugFlag);

            if (CheckPatternsAgainstChargeOne && chargeState != 1)
            {
                HornTransformResults recordCharge1;
                int fitCountBasisCharge1;
                var bestFitCharge1 = _isotopeFitScorer.GetFitScore(peakData, 1, ref peakCharge1, out recordCharge1,
                                                                   deleteThreshold, MinIntensityForScore, LeftFitStringencyFactor,
                                                                   RightFitStringencyFactor, out fitCountBasisCharge1, ShowTraceMessages);

                //double bestFitCharge1 = _isotopeFitter.GetFitScore(peakData, 1, peakCharge1, recordCharge1, _deleteIntensityThreshold, _minTheoreticalIntensityForScore, DebugFlag);
                //_isotopeFitter.GetZeroingMassRange(_zeroingStartMz, _zeroingStopMz, record.DeltaMz, _deleteIntensityThreshold, DebugFlag);
                double startMz1 = 0;
                double stopMz1  = 0;
                _isotopeFitScorer.GetZeroingMassRange(out startMz1, out stopMz1, record.DeltaMz, deleteThreshold,
                                                      ShowTraceMessages);
                if (bestFit > MaxFitAllowed && bestFitCharge1 < MaxFitAllowed)
                {
                    bestFit        = bestFitCharge1;
                    fitCountBasis  = fitCountBasisCharge1;
                    peak           = peakCharge1;
                    record         = new HornTransformResults(recordCharge1);
                    zeroingStartMz = startMz1;
                    zeroingStopMz  = stopMz1;
                    chargeState    = 1;
                }
            }

            if (bestFit > MaxFitAllowed) // check if fit is good enough
            {
                return(false);
            }

            if (ShowTraceMessages)
            {
                Console.Error.WriteLine("\tBack with fit = " + record.Fit);
            }

            // Applications using this DLL should use Abundance instead of AbundanceInt
            record.Abundance   = peak.Intensity;
            record.ChargeState = chargeState;

            ThrashV1Peak monoPeak;
            var          monoMz = record.MonoMw / record.ChargeState + ChargeCarrierMass;

            // used when _reportO18Plus2Da is true.
            ThrashV1Peak m3Peak;
            var          monoPlus2Mz = record.MonoMw / record.ChargeState + 2.0 / record.ChargeState + ChargeCarrierMass;

            peakData.FindPeak(monoMz - peak.FWHM, monoMz + peak.FWHM, out monoPeak);
            peakData.FindPeak(monoPlus2Mz - peak.FWHM, monoPlus2Mz + peak.FWHM, out m3Peak);

            record.MonoIntensity      = (int)monoPeak.Intensity;
            record.MonoPlus2Intensity = (int)m3Peak.Intensity;
            record.SignalToNoise      = peak.SignalToNoiseDbl;
            record.FWHM      = peak.FWHM;
            record.PeakIndex = peak.PeakIndex;

            SetIsotopeDistributionToZero(peakData, peak, zeroingStartMz, zeroingStopMz, record.MonoMw, chargeState, true,
                                         record, ShowTraceMessages);
            if (ShowTraceMessages)
            {
                Console.Error.WriteLine("Performed deisotoping of " + peak.Mz);
            }
            return(true);
        }
コード例 #19
0
        public void PerformTransform(
            float backgroundIntensity, float minPeptideIntensity, int maxProcessingTimeMinutes,
            ref float[] mzs, ref float[] intensities,
            ref ThrashV1Peak[] peaks, ref HornTransformResults[] transformResults,
            out bool processingAborted)
        {
            PercentDone       = 0;
            processingAborted = false;

            var numPoints = mzs.Length;

            if (mzs.Length == 0)
            {
                return;
            }

            // mzs should be in sorted order
            double minMz         = mzs[0];
            double maxMz         = mzs[numPoints - 1];
            var    mzList        = new List <double>(mzs.Select(x => (double)x));
            var    intensityList = new List <double>(intensities.Select(x => (double)x));

            var peakData = new PeakData();

            peakData.SetPeaks(peaks);
            peakData.MzList        = mzList;
            peakData.IntensityList = intensityList;

            if (IsMZRangeUsed)
            {
                minMz = MinMZ;
                maxMz = MaxMZ;
            }

            //loads 'currentPeak' with the most intense peak within minMZ and maxMZ
            ThrashV1Peak currentPeak;
            var          found = peakData.GetNextPeak(minMz, maxMz, out currentPeak);
            //var fwhm_SN = currentPeak.FWHM;

            var transformRecords = new List <HornTransformResults>();
            var numTotalPeaks    = peakData.GetNumPeaks();

            StatusMessage = "Performing Horn Transform on peaks";
            var startTime = DateTime.UtcNow;

            while (found)
            {
                var numPeaksLeft = peakData.GetNumUnprocessedPeaks();
                PercentDone = 100 * (numTotalPeaks - numPeaksLeft) / numTotalPeaks;
                if (PercentDone % 5 == 0)
                {
                    StatusMessage = string.Concat("Done with ", Convert.ToString(numTotalPeaks - numPeaksLeft), " of ",
                                                  Convert.ToString(numTotalPeaks), " peaks.");
                }
                if (currentPeak.Intensity < minPeptideIntensity)
                {
                    break;
                }

                //--------------------- Transform performed ------------------------------
                HornTransformResults transformRecord;
                var foundTransform = FindTransform(peakData, ref currentPeak, out transformRecord, backgroundIntensity);
                if (foundTransform && transformRecord.ChargeState <= MaxChargeAllowed)
                {
                    if (IsActualMonoMZUsed)
                    {
                        //retrieve experimental monoisotopic peak
                        var          monoPeakIndex = transformRecord.IsotopePeakIndices[0];
                        ThrashV1Peak monoPeak;
                        peakData.GetPeak(monoPeakIndex, out monoPeak);

                        //set threshold at 20% less than the expected 'distance' to the next peak
                        var errorThreshold = 1.003 / transformRecord.ChargeState;
                        errorThreshold = errorThreshold - errorThreshold * 0.2;

                        var calcMonoMz = transformRecord.MonoMw / transformRecord.ChargeState + 1.00727638;

                        if (Math.Abs(calcMonoMz - monoPeak.Mz) < errorThreshold)
                        {
                            transformRecord.MonoMw = monoPeak.Mz * transformRecord.ChargeState -
                                                     1.00727638 * transformRecord.ChargeState;
                        }
                    }
                    transformRecords.Add(transformRecord);
                }

                if (DateTime.UtcNow.Subtract(startTime).TotalMinutes > maxProcessingTimeMinutes)
                {
                    processingAborted = true;
                    found             = false;
                }
                else
                {
                    found = peakData.GetNextPeak(minMz, maxMz, out currentPeak);
                }
            }
            PercentDone = 100;

            // Done with the transform. Lets copy them all to the given memory structure.
            //Console.WriteLine("Done with Mass Transform. Found " + transformRecords.Count + " features");

            transformResults = transformRecords.ToArray();
            PercentDone      = 100;
        }
コード例 #20
0
        /// <summary>
        ///     calculates the fit score between the theoretical distribution stored and the observed data. Normalizes the observed
        ///     intensity by specified intensity.
        /// </summary>
        /// <param name="peakData"> variable which stores the data itself</param>
        /// <param name="chargeState"> charge state at which we want to compute the peak.</param>
        /// <param name="peak"> peak for which we want to compute the fit function.</param>
        /// <param name="mzDelta">specifies the mass delta between theoretical and observed m/z with the best fit so far.</param>
        /// <param name="minIntensityForScore">minimum intensity for score</param>
        /// <param name="pointsUsed">number of points used</param>
        /// <param name="debug">debug output flag</param>
        public override double FitScore(PeakData peakData, int chargeState, ThrashV1Peak peak, double mzDelta,
                                        double minIntensityForScore, out int pointsUsed, bool debug = false)
        {
            pointsUsed = 0;
            var numPoints = TheoreticalDistMzs.Count;

            if (numPoints < 3)
            {
                return(1);
            }

            double fit      = 0;
            double sum      = 0;
            double lastYVal = 0;
            double diff     = 0;

            for (var pointNum = 0; pointNum < numPoints; pointNum++)
            {
                var mz = TheoreticalDistMzs[pointNum] + mzDelta;
                var theoreticalIntensity = TheoreticalDistIntensities[pointNum];

                // observed intensities have to be normalized so that the maximum intensity is 100,
                if (theoreticalIntensity >= minIntensityForScore && diff >= 0 && theoreticalIntensity < lastYVal)
                {
                    var          found = false;
                    ThrashV1Peak foundPeak;
                    // remember you might be searching for the current peak (which has already been
                    // taken out of the list of peaks. So first check it.
                    if (Math.Abs(peak.Mz - mz) < 2 * peak.FWHM)
                    {
                        found     = true;
                        foundPeak = peak;
                    }
                    else
                    {
                        peakData.FindPeak(mz - peak.FWHM, mz + peak.FWHM, out foundPeak);
                        if (foundPeak.Mz > 0)
                        {
                            found = true;
                        }
                    }

                    if (found)
                    {
                        var observedIntensity = 100 * foundPeak.Intensity / peak.Intensity;
                        var intensityDiff     = observedIntensity - theoreticalIntensity;
                        var intensityAvg      = (observedIntensity + theoreticalIntensity) / 2;
                        fit += intensityDiff * intensityDiff;
                        sum += intensityAvg * intensityAvg;
                    }
                    else
                    {
                        fit += theoreticalIntensity * theoreticalIntensity;
                        sum += theoreticalIntensity * theoreticalIntensity;
                    }
                    pointsUsed++;
                }
                diff     = theoreticalIntensity - lastYVal;
                lastYVal = theoreticalIntensity;
            }

            return(fit / (sum + 0.001));
        }
コード例 #21
0
        /// <summary>
        ///     Gets the charge state (determined by AutoCorrelation algorithm) for a peak in some data.
        /// </summary>
        /// <param name="peak">is the peak whose charge we want to detect.</param>
        /// <param name="peakData">is the PeakData object containing raw data, peaks, etc which are used in the process.</param>
        /// <param name="debug"></param>
        /// <returns>Returns the charge of the feature.</returns>
        public static int GetChargeState(ThrashV1Peak peak, PeakData peakData, bool debug)
        {
            var minus      = 0.1;
            var plus       = 1.1; // right direction to look
            var startIndex = PeakIndex.GetNearest(peakData.MzList, peak.Mz - peak.FWHM - minus, peak.DataIndex);
            var stopIndex  = PeakIndex.GetNearest(peakData.MzList, peak.Mz + peak.FWHM + plus, peak.DataIndex);
            var numPts     = stopIndex - startIndex;
            var numL       = numPts;

            if (numPts < 5)
            {
                return(-1);
            }

            if (numPts < 256)
            {
                numL = 10 * numPts;
            }

            // TODO: PattersonChargeStateCalculator does a lot of funny stuff around here.
            // variable to help us perform spline interpolation.
            // count is stopIndex - startIndex + 1 because we need to include the values at stopIndex as well
            // NOTE: This output is different from what the DeconEngineV2 code outputs; there are notes in that code
            //    wondering if there was a bug in the previous implementation imported from VB, of starting at startIndex + 1.
            //    That code performed interpolation on the range from startIndex + 1 to stopIndex, inclusive, and minMz set to PeakData.MzList[startIndex + 1].
            //    This code can produce output that more closely matches the DeconEngineV2 output by using
            //    "startIndex, stopIndex - startIndex + 2" as the parameters to "GetRange()", and setting minMz to PeakData.MzList[startIndex + 1].
            //    Since using startIndex and stopIndex directly produces output that mostly differs on fit score by a small amount,
            //    we are changing this code to use them.
            var interpolator = CubicSpline.InterpolateNaturalSorted(
                peakData.MzList.GetRange(startIndex, stopIndex - startIndex + 1).ToArray(),
                peakData.IntensityList.GetRange(startIndex, stopIndex - startIndex + 1).ToArray());

            var minMz = peakData.MzList[startIndex];
            var maxMz = peakData.MzList[stopIndex];

            // List to store the interpolated intensities of the region on which we performed the cubic spline interpolation.
            var iv = new List <double>(numL);

            for (var i = 0; i < numL; i++)
            {
                var xVal = minMz + (maxMz - minMz) * i / numL;
                var fVal = interpolator.Interpolate(xVal);
                iv.Add(fVal);
            }

            if (debug)
            {
                Console.Error.WriteLine("mz,intensity");
                for (var i = 0; i < numL; i++)
                {
                    var xVal = minMz + (maxMz - minMz) * i / numL;
                    Console.Error.WriteLine(xVal + "," + iv[i]);
                }
            }

            // List to store the auto correlation values at the points in the region.
            var autoCorrelationScores = ACss(iv.ToArray());

            if (debug)
            {
                Console.Error.WriteLine("AutoCorrelation values");
                for (var i = 0; i < autoCorrelationScores.Count; i++)
                {
                    var score = autoCorrelationScores[i];
                    Console.Error.WriteLine((maxMz - minMz) * i / numL + "," + score);
                }
            }

            var minN = 0;

            while (minN < numL - 1 && autoCorrelationScores[minN] > autoCorrelationScores[minN + 1])
            {
                minN++;
            }
            var success = HighestChargeStatePeak(minMz, maxMz, minN, autoCorrelationScores, MaxCharge, out var bestAcScore, out _);

            if (!success)
            {
                return(-1); // Didn't find anything
            }
            // List to temporarily store charge list. These charges are calculated at peak values of auto correlation.
            // Now go back through the CS peaks and make a list of all CS that are at least 10% of the highest
            var charges = GenerateChargeStates(minMz, maxMz, minN, autoCorrelationScores, MaxCharge, bestAcScore);

            // Get the final CS value to be returned
            var returnChargeStateVal = -1;
            // TODO: PattersonChargeStateCalculator really doesn't match the following code.
            var fwhm = peak.FWHM; // Store a copy of the FWHM to avoid modifying the actual value

            if (fwhm > 0.1)
            {
                fwhm = 0.1;
            }

            for (var i = 0; i < charges.Count; i++)
            {
                // no point retesting previous charge.
                var tempChargeState = charges[i];
                var skip            = false;
                for (var j = 0; j < i; j++)
                {
                    if (charges[j] == tempChargeState)
                    {
                        skip = true;
                        break;
                    }
                }
                if (skip)
                {
                    continue;
                }
                if (tempChargeState > 0)
                {
                    var peakA = peak.Mz + 1.0 / tempChargeState;
                    var found = peakData.GetPeakFromAllOriginalIntensity(peakA - fwhm, peakA + fwhm, out var isoPeak);
                    if (found)
                    {
                        returnChargeStateVal = tempChargeState;
                        if (isoPeak.Mz * tempChargeState < 3000)
                        {
                            break;
                        }
                        // if the mass is greater than 3000, lets make sure that multiple isotopes exist.
                        peakA = peak.Mz - 1.03 / tempChargeState;
                        found = peakData.GetPeakFromAllOriginalIntensity(peakA - fwhm, peakA + fwhm, out isoPeak);
                        if (found)
                        {
                            return(tempChargeState);
                        }
                    }
                    else
                    {
                        peakA = peak.Mz - 1.0 / tempChargeState;
                        found = peakData.GetPeakFromAllOriginalIntensity(peakA - fwhm, peakA + fwhm, out isoPeak);
                        if (found && isoPeak.Mz * tempChargeState < 3000)
                        {
                            return(tempChargeState);
                        }
                    }
                }
            }
            return(returnChargeStateVal);
        }
コード例 #22
0
        public virtual bool FindTransform(PeakData peakData, ref clsPeak peak, out clsHornTransformResults record,
                                          double backgroundIntensity = 0)
        {
            record = new clsHornTransformResults();
            if (peak.SignalToNoise < TransformParameters.MinS2N || peak.FWHM.Equals(0))
            {
                return(false);
            }

            //var resolution = peak.Mz / peak.FWHM;
            var chargeState = AutoCorrelationChargeDetermination.GetChargeState(peak, peakData, DebugFlag);

            if (chargeState == -1 && TransformParameters.CheckAllPatternsAgainstCharge1)
            {
                chargeState = 1;
            }

            if (DebugFlag)
            {
                Console.Error.WriteLine("Deisotoping :" + peak.Mz);
                Console.Error.WriteLine("Charge = " + chargeState);
            }

            if (chargeState == -1)
            {
                return(false);
            }

            if ((peak.Mz + TransformParameters.CCMass) * chargeState > TransformParameters.MaxMW)
            {
                return(false);
            }

            if (TransformParameters.O16O18Media)
            {
                if (peak.FWHM < 1.0 / chargeState)
                {
                    // move back by 4 Da and see if there is a peak.
                    var     minMz = peak.Mz - 4.0 / chargeState - peak.FWHM;
                    var     maxMz = peak.Mz - 4.0 / chargeState + peak.FWHM;
                    clsPeak o16Peak;
                    var     found = peakData.GetPeak(minMz, maxMz, out o16Peak);
                    if (found && !o16Peak.Mz.Equals(peak.Mz))
                    {
                        // put back the current into the to be processed list of peaks.
                        peakData.AddPeakToProcessingList(peak);
                        // reset peak to the right peak so that the calling function may
                        // know that the peak might have changed in the O16/O18 business
                        peak = o16Peak;
                        peakData.RemovePeak(peak);
                        return(FindTransform(peakData, ref peak, out record, backgroundIntensity));
                    }
                }
            }

            var peakCharge1 = new clsPeak(peak);

            // Until now, we have been using constant theoretical delete intensity threshold..
            // instead, from now, we should use one that is proportional to intensity, for more intense peaks.
            // However this will not solve all problems. If thrashing occurs, then the peak intensity will
            // change when the function returns and we may not delete far enough.
            //double deleteThreshold = backgroundIntensity / peak.Intensity * 100;
            //if (backgroundIntensity ==0 || deleteThreshold > _deleteIntensityThreshold)
            //  deleteThreshold = _deleteIntensityThreshold;
            var deleteThreshold = TransformParameters.DeleteIntensityThreshold;
            int fitCountBasis;
            var bestFit = TransformParameters.IsotopeFitScorer.GetFitScore(peakData, chargeState, ref peak, out record, deleteThreshold,
                                                                           TransformParameters.MinIntensityForScore, TransformParameters.LeftFitStringencyFactor, TransformParameters.RightFitStringencyFactor, out fitCountBasis,
                                                                           DebugFlag);

            // When deleting an isotopic profile, this value is set to the first m/z to perform deletion at.
            double zeroingStartMz;
            // When deleting an isotopic profile, this value is set to the last m/z to perform deletion at.
            double zeroingStopMz;

            TransformParameters.IsotopeFitScorer.GetZeroingMassRange(out zeroingStartMz, out zeroingStopMz, record.DeltaMz, deleteThreshold,
                                                                     DebugFlag);
            //bestFit = _isotopeFitter.GetFitScore(peakData, chargeState, peak, record, _deleteIntensityThreshold, _minTheoreticalIntensityForScore, DebugFlag);
            //_isotopeFitter.GetZeroingMassRange(_zeroingStartMz, _zeroingStopMz, record.DeltaMz, _deleteIntensityThreshold, DebugFlag);

            if (TransformParameters.CheckAllPatternsAgainstCharge1 && chargeState != 1)
            {
                clsHornTransformResults recordCharge1;
                int fitCountBasisCharge1;
                var bestFitCharge1 = TransformParameters.IsotopeFitScorer.GetFitScore(peakData, 1, ref peakCharge1, out recordCharge1,
                                                                                      deleteThreshold, TransformParameters.MinIntensityForScore, TransformParameters.LeftFitStringencyFactor,
                                                                                      TransformParameters.RightFitStringencyFactor, out fitCountBasisCharge1, DebugFlag);

                //double bestFitCharge1 = _isotopeFitter.GetFitScore(peakData, 1, peakCharge1, recordCharge1, _deleteIntensityThreshold, _minTheoreticalIntensityForScore, DebugFlag);
                //_isotopeFitter.GetZeroingMassRange(_zeroingStartMz, _zeroingStopMz, record.DeltaMz, _deleteIntensityThreshold, DebugFlag);
                double startMz1 = 0;
                double stopMz1  = 0;
                TransformParameters.IsotopeFitScorer.GetZeroingMassRange(out startMz1, out stopMz1, record.DeltaMz, deleteThreshold, DebugFlag);
                if (bestFit > TransformParameters.MaxFit && bestFitCharge1 < TransformParameters.MaxFit)
                {
                    bestFit        = bestFitCharge1;
                    fitCountBasis  = fitCountBasisCharge1;
                    peak           = peakCharge1;
                    record         = new clsHornTransformResults(recordCharge1);
                    zeroingStartMz = startMz1;
                    zeroingStopMz  = stopMz1;
                    chargeState    = 1;
                }
            }

            if (bestFit > TransformParameters.MaxFit) // check if fit is good enough
            {
                return(false);
            }

            if (DebugFlag)
            {
                Console.Error.WriteLine("\tBack with fit = " + record.Fit);
            }

            // Applications using this DLL should use Abundance instead of AbundanceInt
            record.Abundance   = peak.Intensity;
            record.ChargeState = chargeState;

            clsPeak monoPeak;
            var     monoMz = record.MonoMw / record.ChargeState + TransformParameters.CCMass;

            // used when _reportO18Plus2Da is true.
            clsPeak m3Peak;
            var     monoPlus2Mz = record.MonoMw / record.ChargeState + 2.0 / record.ChargeState + TransformParameters.CCMass;

            peakData.FindPeak(monoMz - peak.FWHM, monoMz + peak.FWHM, out monoPeak);
            peakData.FindPeak(monoPlus2Mz - peak.FWHM, monoPlus2Mz + peak.FWHM, out m3Peak);

            record.MonoIntensity      = (int)monoPeak.Intensity;
            record.MonoPlus2Intensity = (int)m3Peak.Intensity;
            record.SignalToNoise      = peak.SignalToNoise;
            record.FWHM      = peak.FWHM;
            record.PeakIndex = peak.PeakIndex;

            SetIsotopeDistributionToZero(peakData, peak, zeroingStartMz, zeroingStopMz, record.MonoMw, chargeState, true,
                                         record, DebugFlag);
            if (DebugFlag)
            {
                Console.Error.WriteLine("Performed deisotoping of " + peak.Mz);
            }
            return(true);
        }