/// <summary>
        /// Function to search bigest peak in spectra around MZ mass, interval of search is specified in ppm by Error parameter
        /// </summary>
        /// <param name="MZ">Mass, to search around of</param>
        /// <param name="Error">Interval of +/- ppm to be searched in</param>
        /// <returns>If found returns data point, otherwise returns zero data point</returns>
        public MZData FindBiggestPeak(double MZ, double Error)
        {
            double LowerMass = MZPlusPPM(MZ, -Error);
            double UpperMass = MZPlusPPM(MZ, Error);

            int LowerIndex = FindMassAbove(LowerMass);
            int UpperIndex = FindMassBelow(UpperMass);

            if (LowerIndex > UpperIndex || LowerIndex == -1)  //if nothing if found - return zero data point
            {
                return(MZData.CreateZero(Scan));
            }

            double MaxInt   = Data[LowerIndex].Intensity;
            int    MaxIndex = LowerIndex;

            LowerIndex++;
            while (LowerIndex <= UpperIndex)   //if there are more then one data point - return most intensive
            {
                if (Data[LowerIndex].Intensity > MaxInt)
                {
                    MaxInt   = Data[LowerIndex].Intensity;
                    MaxIndex = LowerIndex;
                }
                LowerIndex++;
            }
            return(Data[MaxIndex]);
        }
        /// <summary>
        /// Function to search nearest peak in spectra around MZ mass, interval of search is specified in ppm by Error parameter
        /// </summary>
        /// <param name="MZ">Mass, to search around of</param>
        /// <param name="Error">Interval of +/- ppm to be searched in</param>
        /// <returns>If found returns data point, otherwise returns zero data point</returns>
        public MZData FindNearestPeak(double MZ, double Error)
        {
            double LowerMass = MZPlusPPM(MZ, -Error);
            double UpperMass = MZPlusPPM(MZ, Error);

            int LowerIndex = FindMassAbove(LowerMass);
            int UpperIndex = FindMassBelow(UpperMass);

            if (LowerIndex > UpperIndex || LowerIndex == -1)  //if nothing if found - return zero data point
            {
                return(MZData.CreateZero(Scan));
            }

            while (LowerIndex < UpperIndex)   //if there are more then one data point - return closest by mass
            //Console.WriteLine("Warning: Two peaks at distanse of {0} ppm in scan {1} mass {2}",
            //    ((Data[LowerIndex].Mass - Data[LowerIndex+1].Mass) * 500000.0) / (Data[LowerIndex].Mass + Data[LowerIndex+1].Mass),
            //    Scan, Data[LowerIndex].Mass);
            {
                if (LowerIndex == Data.GetLength(0) - 1 ||
                    Math.Abs(MZ - Data[LowerIndex].Mass) < Math.Abs(MZ - Data[LowerIndex + 1].Mass))
                {
                    break;
                }
                LowerIndex++;
            }
            return(Data[LowerIndex]);
        }
        /// <summary>
        /// Creates zero intesity fake data point
        /// That is necessary for chromatograms leading/trailing zeroes and so on
        /// </summary>
        public static MZData CreateZero(int Scan)
        {
            MZData Res = new MZData();

            Res.Mass      = 0.0;
            Res.Intensity = 0.0;
            Res.Scan      = Scan;
            return(Res);
        }
Exemple #4
0
/*        public MZData[] PeakDetect(MZData[] Data ){
 *
 *          PeakDetecting.PeakDetector pd = new PeakDetecting.PeakDetector();
 *          PeakDetecting.peakinside[] Peaks = new PeakDetecting.peakinside[1];
 *          pd.PeaksDetecting(ref Data, ref Peaks);
 *              MZData[] OutData = new MZData[Peaks.GetLength(0)];
 *          for (int i = 0 ; i < Peaks.GetLength(0) ; i++){
 *              OutData[i].Intensity = Peaks[i].Value;
 *              OutData[i].Mass = Peaks[i].Center;
 *          }
 *          return OutData;
 *      }*/

        public MZData[] Centroid(MZData[] Data, int Len, bool StickMode /* former "in" */)
        {
            int    total = 0, u;
            int    o = 0, i = 0, count = Len;
            double sumIi, sumI, last = 0.0;
            double du        = 0.0;
            bool   goingdown = false;

            MZData[] OutData;

            if (StickMode)
            {
                //считаем пока не начнутся нули или пока следующий не станет меньше помассе
                for (i = 1; i < count; i++)
                {
                    if (Data[i].Mass < Data[i - 1].Mass || Data[i].Mass == 0)
                    {
                        break;
                    }
                }
                OutData = new MZData[i];
                count   = i;
                for (i = 0; i < count; i++)
                {
                    OutData[i].Intensity = Data[i].Intensity;
                    OutData[i].Mass      = Data[i].Mass;
                }
                return(OutData);
            }


            //пропуск начальных нулей
            while (i < count && Data[i].Intensity == 0.0)
            {
                ++i;
            }

            //считает области больше нуля
            while (i < count)
            {
                while (i < count && Data[i].Intensity != 0.0)
                {
                    if (last > Data[i].Intensity)
                    {
                        goingdown = true;
                    }
                    else
                    {
                        if (goingdown)
                        {
                            ++total;
                            goingdown = false;
                        }
                    }

                    last = Data[i].Intensity;
                    ++i;
                }

                last      = 0.0;
                goingdown = false;

                while (i < count && Data[i].Intensity == 0.0)
                {
                    i++;
                }

                total++;
            }

            //запасает память на подсчитанные области
            OutData = new MZData[total];
            i       = 0; o = 0; total = 0; last = 0.0; goingdown = false;

            while (i < count && Data[i].Intensity == 0.0)
            {
                i++;
            }

            while (i < count)
            {
                sumIi = sumI = 0.0;
                o     = i - 1;
                while (i < count && Data[i].Intensity != 0.0)
                {
                    //если пошло на спад
                    if (last > Data[i].Intensity)
                    {
                        goingdown = true;
                    }
                    else
                    {
                        if (goingdown)
                        {
                            u = Convert.ToInt32((sumIi / sumI) /* + 0.5*/);
                            OutData[total].Intensity = sumI;
                            OutData[total].Mass      = Data[o + u].Mass;
                            ++total;

                            sumIi     = sumI = 0.0;
                            o         = i - 1;
                            goingdown = false;
                        }
                    }

                    sumIi += Data[i].Intensity * (i - o);
                    sumI  += Data[i].Intensity;

                    last = Data[i].Intensity;
                    i++;
                }

                u  = Convert.ToInt32((sumIi / sumI) /*+0.5*/);
                du = sumIi / sumI - (double)u;
                //интенсивность по интегралу
                OutData[total].Intensity = sumI;
                //сентроид - по апексу
                //OutData[total].Mass = Data[o+u].Mass;
                //центроид по центру
                OutData[total].Mass = Data[o + u].Mass * (1 - du) + Data[o + u + 1].Mass * du;

                last      = 0.0;
                goingdown = false;

                while (i < count && Data[i].Intensity == 0.0)
                {
                    i++;
                }
                total++;
            }
            return(OutData);
        }
        /*        public MZData[] PeakDetect(MZData[] Data ){

            PeakDetecting.PeakDetector pd = new PeakDetecting.PeakDetector();
            PeakDetecting.peakinside[] Peaks = new PeakDetecting.peakinside[1];
            pd.PeaksDetecting(ref Data, ref Peaks);
            MZData[] OutData = new MZData[Peaks.GetLength(0)];
            for (int i = 0 ; i < Peaks.GetLength(0) ; i++){
                OutData[i].Intensity = Peaks[i].Value;
                OutData[i].Mass = Peaks[i].Center;
            }
            return OutData;
        }*/
        public MZData[] Centroid(MZData[] Data,int Len, bool StickMode /* former "in" */)
        {
            int total = 0, u;
            int o = 0, i = 0, count = Len;
            double sumIi, sumI, last = 0.0;
            double du = 0.0;
            bool goingdown = false;
            MZData[] OutData;

            if (StickMode) {
                //считаем пока не начнутся нули или пока следующий не станет меньше помассе
                for ( i = 1 ; i<count ; i++){
                    if (Data[i].Mass < Data[i-1].Mass || Data[i].Mass == 0){
                        break;
                    }
                }
                OutData = new MZData[i];
                count = i;
                for (i=0; i<count ; i++){
                    OutData[i].Intensity = Data[i].Intensity;
                    OutData[i].Mass = Data[i].Mass;
                }
                return OutData;
            }

            //пропуск начальных нулей
            while(i < count && Data[i].Intensity == 0.0) ++i;

            //считает области больше нуля
            while(i < count)
            {
                while(i < count && Data[i].Intensity != 0.0)
                {
                    if(last > Data[i].Intensity) {
                        goingdown = true;
                    }else{
                        if(goingdown) {
                            ++total;
                            goingdown = false;
                        }
                    }

                    last = Data[i].Intensity;
                    ++i;
                }

                last = 0.0;
                goingdown = false;

                while(i < count && Data[i].Intensity == 0.0)
                    i++;

                total++;
            }

            //запасает память на подсчитанные области
            OutData = new MZData[total];
            i = 0; o = 0; total = 0; last = 0.0; goingdown = false;

            while(i < count && Data[i].Intensity == 0.0) i++;

            while(i < count)
            {
                sumIi = sumI = 0.0;
                o = i -1;
                while(i < count && Data[i].Intensity != 0.0){

                    //если пошло на спад
                    if(last > Data[i].Intensity) {
                        goingdown = true;
                    }else{
                        if(goingdown) {
                            u = Convert.ToInt32((sumIi / sumI)/* + 0.5*/);
                            OutData[total].Intensity = sumI;
                            OutData[total].Mass = Data[o+u].Mass;
                            ++total;

                            sumIi = sumI = 0.0;
                            o = i -1;
                            goingdown = false;
                        }
                    }

                    sumIi += Data[i].Intensity*(i-o);
                    sumI += Data[i].Intensity;

                    last = Data[i].Intensity;
                    i++;
                }

                u = Convert.ToInt32((sumIi / sumI) /*+0.5*/ );
                du = sumIi / sumI - (double)u;
                //интенсивность по интегралу
                OutData[total].Intensity = sumI;
                //сентроид - по апексу
                //OutData[total].Mass = Data[o+u].Mass;
                //центроид по центру
                OutData[total].Mass = Data[o+u].Mass*(1-du) + Data[o+u+1].Mass*du;

                last = 0.0;
                goingdown = false;

                while(i < count && Data[i].Intensity == 0.0)
                    i++;
                total++;
            }
            return OutData;
        }