Esempio n. 1
0
        private void SetupPsiMod()
        {
            var parser = new PsiModOboParser();

            PsiModTerm[] modifications = parser.Parse(PsiModOboParserTest.GetFilePath()).ToArray();

            _psiMod38 = modifications.Single(x => x.Id == "MOD:00038");
            //_psiModLookup = PsiModModificationLookup.CreateFromModifications(new[] { _psiMod38 },
            //    _elementProvider);
            _psiModLookup = PsiModModificationLookup.CreateFromModifications(modifications,
                                                                             _elementProvider);
        }
Esempio n. 2
0
        public void PsiModIsotope()
        {
            var parser = new PsiModOboParser();

            PsiModTerm[] modifications = parser.Parse(PsiModOboParserTest.GetFilePath()).ToArray();

            PsiModTerm psiMod402 = modifications.Single(x => x.Id == "MOD:00402");
            IProteoformModificationLookup psiModLookup = PsiModModificationLookup.CreateFromModifications(new[] { psiMod402 },
                                                                                                          _elementProvider);

            this.FindById(psiModLookup, ProFormaKey.Identifier, ProFormaEvidenceType.PsiMod, 402, "MOD:");

            var mod = psiModLookup.GetModification(new ProFormaDescriptor(ProFormaKey.Identifier,
                                                                          ProFormaEvidenceType.PsiMod, "MOD:00402"));

            ChemicalFormula chemicalFormula = new ChemicalFormula(
                new IEntityCardinality <IElement>[]
            {
                new EntityCardinality <IElement>(_elementProvider.GetElement("C"), 22),
                new EntityCardinality <IElement>(_elementProvider.GetElement("H", 1), 30),
                new EntityCardinality <IElement>(_elementProvider.GetElement("H", 2), 8),
                new EntityCardinality <IElement>(_elementProvider.GetElement("N"), 4),
                new EntityCardinality <IElement>(_elementProvider.GetElement("O"), 6),
                new EntityCardinality <IElement>(_elementProvider.GetElement("S"), 1),
            });

            Assert.IsInstanceOf(typeof(IHasChemicalFormula), mod);
            var formulaMod = (IHasChemicalFormula)mod;

            Assert.IsTrue(chemicalFormula.Equals(formulaMod.GetChemicalFormula()));

            Assert.IsInstanceOf(typeof(IIdentifiable), mod);
            var idMod = (IIdentifiable)mod;

            Assert.AreEqual("MOD:00402", idMod.Id);
            Assert.AreEqual("Gygi ICAT(TM) d8 modified cysteine", idMod.Name);
        }
Esempio n. 3
0
        public void BasicTest()
        {
            var parser = new PsiModOboParser();

            List <PsiModTerm> result = new List <PsiModTerm>(parser.Parse(GetFilePath()));

            Assert.IsNotNull(result);
            Assert.AreEqual(2077, result.Count);
            Assert.AreEqual("MOD:00812", result[812].Id);
            Assert.AreEqual("alkylated residue", result[1].Name);
            Assert.AreEqual("A protein modification that effectively converts an L-serine residue to O3-glycosylserine.", result[2].Definition);
            Assert.AreEqual("This term is for organizational use only and should not be assigned. [JSG]", result[3].Comment);

            Assert.AreEqual(146.14, result[813].DiffAvg.Value, 0.001);
            Assert.IsNull(result[434].DiffAvg); // Handle 'none'

            Assert.AreEqual("C 6 H 10 N 0 O 4", result[813].DiffFormula);
            Assert.AreEqual(146.057909, result[813].DiffMono.Value, 0.001);

            Assert.AreEqual(247.25, result[813].MassAvg.Value, 0.001);
            Assert.AreEqual("C 10 H 17 N 1 O 6", result[813].Formula);
            Assert.AreEqual(247.105587, result[813].MassMono.Value, 0.001);

            Assert.AreEqual(true, result[4].IsObsolete);
            Assert.AreEqual(false, result[813].IsObsolete);

            // Should be just one character unless cross link
            Assert.AreEqual('T', result[813].Origin.Single());
            CollectionAssert.AreEquivalent(new[] { 'C', 'C' }, result[34].Origin);             // Cross-link, origin is C, C
            CollectionAssert.AreEquivalent(new[] { 'K', 'K', 'K', 'K' }, result[1934].Origin); // Cross-link, 4 AA origin
            Assert.AreEqual(null, result[1038].Origin);                                        // says 'none'
            Assert.AreEqual(null, result[458].Origin);                                         // Special case for 'X'

            Assert.AreEqual(null, result[0].Source);
            Assert.AreEqual(null, result[1].Source);
            Assert.AreEqual(PsiModModificationSource.Natural, result[812].Source);
            Assert.AreEqual(PsiModModificationSource.Artifact, result[54].Source);
            Assert.AreEqual(PsiModModificationSource.Hypothetical, result[231].Source);

            Assert.AreEqual(null, result[813].Terminus); // says 'none'
            Assert.AreEqual(null, result[9].Terminus);   // doesn't exist
            Assert.AreEqual(Terminus.N, result[30].Terminus);
            Assert.AreEqual(Terminus.C, result[90].Terminus);

            Assert.IsNull(result[4].IsA);
            Assert.AreEqual(2, result[5].IsA.Count);
            CollectionAssert.Contains(result[5].IsA.ToList(), "MOD:00396");
            CollectionAssert.Contains(result[5].IsA.ToList(), "MOD:00917");

            PsiModTerm formylMethionine = result[30];

            Assert.AreEqual(9, formylMethionine.ExternalReferences.Count);
            CollectionAssert.Contains(formylMethionine.ExternalReferences.Select(x => x.Id).ToList(), "AA0021#FMET");
            CollectionAssert.Contains(formylMethionine.ExternalReferences.Select(x => x.Name).ToList(), "RESID");

            Assert.AreEqual(11, formylMethionine.Synonyms.Count);
            CollectionAssert.Contains(formylMethionine.Synonyms.Select(x => x.Scope).ToList(), "EXACT");
            CollectionAssert.Contains(formylMethionine.Synonyms.Select(x => x.Text).ToList(), "2-formylamino-4-(methylthio)butanoic acid");
            CollectionAssert.Contains(formylMethionine.Synonyms.Select(x => x.Type).ToList(), "PSI-MOD-alternate");

            // Check formal charge
            Assert.AreEqual("MOD:00083", result[83].Id);
            PsiModTerm trimethylLysine = result[83];

            Assert.AreEqual(1, trimethylLysine.FormalCharge);

            PsiModTerm dimethylLysine = result[84];

            Assert.AreEqual(0, dimethylLysine.FormalCharge);

            PsiModTerm hexakis = result[147];

            Assert.AreEqual(-3, hexakis.FormalCharge);

            PsiModTerm stearoylated = result[2001];

            Assert.AreEqual("MOD:02001", stearoylated.Id);
            Assert.IsNull(stearoylated.ExternalReferences);
            Assert.IsNull(stearoylated.Remap);

            // Check for Obsolete and Remap
            PsiModTerm residueMethylEster = result[407];

            Assert.IsTrue(residueMethylEster.IsObsolete);
            Assert.AreEqual("MOD:00599", residueMethylEster.Remap);
        }