private void CheckPlexType(IsobaricType plexType, string expectHeader, string expectValue)
        {
            var ann = new IdentifiedSpectrum();

            var pqr = new IsobaricItem()
            {
                PlexType         = plexType,
                Valid            = true,
                ValidProbability = 0.0005
            };

            var refItems = plexType.GetDefinition().Items;

            foreach (var item in refItems)
            {
                pqr[item.Index] = item.Mass;
            }

            ann.SetIsobaricItem(pqr);

            //从实例构建converter
            var converter = new ITraqItemPlexConverter <IAnnotation>();
            List <IPropertyConverter <IAnnotation> > converters = new List <IPropertyConverter <IAnnotation> >();

            converters.Add(converter);
            converters.AddRange(converter.GetRelativeConverter(new IAnnotation[] { ann }.ToList()));
            CompositePropertyConverter <IAnnotation> finalConverter = new CompositePropertyConverter <IAnnotation>(converters, ',');

            if (exportToConsole)
            {
                Console.WriteLine(finalConverter.Name);
            }
            Assert.AreEqual(expectHeader, finalConverter.Name);

            var line1 = finalConverter.GetProperty(ann);

            if (exportToConsole)
            {
                Console.WriteLine(line1);
            }
            Assert.AreEqual(expectValue, line1);

            var protein2 = new IdentifiedSpectrum();

            //从factory根据header构建converter
            var finalC = IdentifiedSpectrumPropertyConverterFactory.GetInstance().GetConverters(finalConverter.Name, ',');

            finalC.SetProperty(protein2, line1);

            var line2 = finalConverter.GetProperty(protein2);

            Assert.AreEqual(line1, line2);
        }
    private void CheckPlexType(IsobaricType plexType, string expectHeader, string expectValue)
    {
      var ann = new IdentifiedSpectrum();

      var pqr = new IsobaricItem()
      {
        PlexType = plexType,
        Valid = true,
        ValidProbability = 0.0005
      };

      var refItems = plexType.GetDefinition().Items;
      foreach (var item in refItems)
      {
        pqr[item.Index] = item.Mass;
      }

      ann.SetIsobaricItem(pqr);

      //从实例构建converter
      var converter = new ITraqItemPlexConverter<IAnnotation>();
      List<IPropertyConverter<IAnnotation>> converters = new List<IPropertyConverter<IAnnotation>>();
      converters.Add(converter);
      converters.AddRange(converter.GetRelativeConverter(new IAnnotation[] { ann }.ToList()));
      CompositePropertyConverter<IAnnotation> finalConverter = new CompositePropertyConverter<IAnnotation>(converters, ',');

      if (exportToConsole)
      {
        Console.WriteLine(finalConverter.Name);
      }
      Assert.AreEqual(expectHeader, finalConverter.Name);

      var line1 = finalConverter.GetProperty(ann);
      if (exportToConsole)
      {
        Console.WriteLine(line1);
      }
      Assert.AreEqual(expectValue, line1);

      var protein2 = new IdentifiedSpectrum();

      //从factory根据header构建converter
      var finalC = IdentifiedSpectrumPropertyConverterFactory.GetInstance().GetConverters(finalConverter.Name, ',');
      finalC.SetProperty(protein2, line1);

      var line2 = finalConverter.GetProperty(protein2);
      Assert.AreEqual(line1, line2);
    }
示例#3
0
 public static List <IsobaricIndex> GetFuncs(this IsobaricType plexType)
 {
     return((from item in plexType.GetDefinition().Items
             select new IsobaricIndex(item.Index)).ToList());
 }
 public static IsobaricItemImpl CreateItem(this IsobaricType plexType, IsobaricItem parent)
 {
     return(new IsobaricItemImpl(parent, plexType.GetDefinition()));
 }
示例#5
0
        public static double[][] ParseTable(IsobaricType plexType, string isotopeImpurityFile)
        {
            var definition = plexType.GetDefinition();
            var items      = definition.Items;

            string[] lines = File.ReadAllLines(isotopeImpurityFile);
            if (lines.Length < items.Length + 1)
            {
                throw new ArgumentException(string.Format("Wrong format of Isotope Impurity Correction Table File of {0}\n{1}", plexType, isotopeImpurityFile));
            }

            //Skip the header line
            lines = lines.Skip(1).ToArray();

            char splitChar;

            if (lines[0].Contains(','))
            {
                splitChar = ',';
            }
            else
            {
                splitChar = '\t';
            }

            //Each line should contain reagent name and five values (-2,-1,0,1,2)
            lines = (from l in lines
                     let s = l.Trim().Split(splitChar)
                             where s.Length == 6
                             select l.Trim()).ToArray();

            if (lines.Length != items.Length)
            {
                throw new ArgumentException(string.Format("Length not equals between plex type {0} and impurity file {1}", plexType, isotopeImpurityFile));
            }

            var ignore = new List <int>();

            for (int i = definition.MaxIndex - 1; i > definition.MinIndex; i--)
            {
                if (!definition.IsValid(i))
                {
                    ignore.Add(i - definition.MinIndex);
                }
            }

            int len = definition.MaxIndex - definition.MinIndex + 1;

            Dictionary <int, double[]> dic = new Dictionary <int, double[]>();
            int index = definition.MinIndex - 1;

            for (int i = 0; i < items.Length; i++)
            {
                var lst = new List <double>();
                for (int j = 0; j < len; j++)
                {
                    lst.Add(0);
                }

                var p = GetIsotopes(lines[i], splitChar, ref index);

                var startPos = items[i].Index - definition.MinIndex - 2;

                var endPos  = Math.Min(len, startPos + 5);
                var fromPos = Math.Max(0, startPos);

                for (int j = fromPos; j < endPos; j++)
                {
                    var pIndex = j - startPos;
                    lst[j] = p[pIndex];
                }

                foreach (var ign in ignore)
                {
                    lst.RemoveAt(ign);
                }
                dic[index] = lst.ToArray();
            }

            return((from key in dic.Keys
                    orderby key
                    select dic[key]).ToArray());
        }