Пример #1
0
 void AddMonosaccharide(Monosaccharide sugar)
 {
     if (composite.ContainsKey(sugar))
     {
         composite[sugar] += 1;
     }
     else
     {
         composite[sugar] = 1;
     }
 }
Пример #2
0
        public override List <IGlycan> Grow(Monosaccharide monosaccharide)
        {
            List <IGlycan> glycans = new List <IGlycan>();

            switch (monosaccharide)
            {
            case Monosaccharide.GlcNAc:
                if (ValidAddGlcNAc())
                {
                    NHighMannose ptr = CreateByAddGlcNAc();
                    glycans.Add(ptr);
                }

                break;

            case Monosaccharide.Man:
                if (ValidAddManCore())
                {
                    NHighMannose ptr = CreateByAddManCore();
                    glycans.Add(ptr);
                }
                else if (ValidAddManBranch())
                {
                    List <NHighMannose> gs = CreateByAddManBranch();
                    glycans.AddRange(gs);
                }
                break;

            case Monosaccharide.Fuc:
                if (ValidAddFucCore())
                {
                    NHighMannose ptr = CreateByAddFucCore();
                    glycans.Add(ptr);
                }
                break;

            default:
                break;
            }
            return(glycans);
        }
Пример #3
0
        public Dictionary <Element, int> Compositions(Monosaccharide sugar)
        {
            // GlcNAc C8H15NO6, Man/Gal C6H12O6, Fuc C6H12O5,  NeuAc C11H19NO9, NeuGc C11H19NO10
            switch (sugar)
            {
            case Monosaccharide.HexNAc:
                return(new Dictionary <Element, int>()
                {
                    { new C(), 8 }, { new H(), 15 }, { new N(), 1 }, { new O(), 6 }
                });

            case Monosaccharide.Hex:
                return(new Dictionary <Element, int>()
                {
                    { new C(), 6 }, { new H(), 12 }, { new O(), 6 }
                });

            case Monosaccharide.Fuc:
                return(new Dictionary <Element, int>()
                {
                    { new C(), 6 }, { new H(), 12 }, { new O(), 5 }
                });

            case Monosaccharide.NeuAc:
                return(new Dictionary <Element, int>()
                {
                    { new C(), 11 }, { new H(), 19 }, { new N(), 1 }, { new O(), 9 }
                });

            case Monosaccharide.NeuGc:
                return(new Dictionary <Element, int>()
                {
                    { new C(), 11 }, { new H(), 19 }, { new N(), 1 }, { new O(), 10 }
                });
            }

            return(new Dictionary <Element, int>());
        }
Пример #4
0
 public abstract List <IGlycan> Grow(Monosaccharide monosaccharide);
Пример #5
0
        // composition in a glycan
        public Dictionary <Element, int> SubCompositions(Monosaccharide sugar, bool permethylated)
        {
            // GlcNAc C8H15NO6, Man/Gal C6H12O6, Fuc C6H12O5,  NeuAc C11H19NO9, NeuGc C11H19NO10
            if (permethylated)
            {
                switch (sugar)
                {
                case Monosaccharide.HexNAc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 11 }, { new H(), 19 }, { new N(), 1 }, { new O(), 5 }
                    });

                case Monosaccharide.Hex:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 9 }, { new H(), 16 }, { new O(), 5 }
                    });

                case Monosaccharide.Fuc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 8 }, { new H(), 14 }, { new O(), 4 }
                    });

                case Monosaccharide.NeuAc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 16 }, { new H(), 27 }, { new N(), 1 }, { new O(), 8 }
                    });

                case Monosaccharide.NeuGc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 17 }, { new H(), 29 }, { new N(), 1 }, { new O(), 9 }
                    });
                }
            }
            else
            {
                switch (sugar)
                {
                case Monosaccharide.HexNAc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 8 }, { new H(), 13 }, { new N(), 1 }, { new O(), 5 }
                    });

                case Monosaccharide.Hex:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 6 }, { new H(), 10 }, { new O(), 5 }
                    });

                case Monosaccharide.Fuc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 6 }, { new H(), 10 }, { new O(), 4 }
                    });

                case Monosaccharide.NeuAc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 11 }, { new H(), 17 }, { new N(), 1 }, { new O(), 8 }
                    });

                case Monosaccharide.NeuGc:
                    return(new Dictionary <Element, int>()
                    {
                        { new C(), 11 }, { new H(), 17 }, { new N(), 1 }, { new O(), 9 }
                    });
                }
            }



            return(new Dictionary <Element, int>());
        }
Пример #6
0
        public Compound Compounds(Monosaccharide sugar)
        {
            Dictionary <Element, int> composition = Compositions(sugar);

            return(new Compound(composition));
        }
Пример #7
0
        public override List <IGlycan> Grow(Monosaccharide monosaccharide)
        {
            List <IGlycan> glycans = new List <IGlycan>();

            switch (monosaccharide)
            {
            case Monosaccharide.GlcNAc:
                if (ValidAddGlcNAcCore())
                {
                    NGlycanComplex ptr = CreateByAddGlcNAcCore();
                    glycans.Add(ptr);
                }
                else if (ValidAddGlcNAc())
                {
                    if (ValidAddGlcNAcBisect())
                    {
                        NGlycanComplex ptr = CreateByAddGlcNAcBisect();
                        glycans.Add(ptr);
                    }
                    if (ValidAddGlcNAcBranch())
                    {
                        List <NGlycanComplex> gs = CreateByAddGlcNAcBranch();
                        glycans.AddRange(gs);
                    }
                }
                break;

            case Monosaccharide.Man:
                if (ValidAddMan())
                {
                    NGlycanComplex ptr = CreateByAddMan();
                    glycans.Add(ptr);
                }
                break;

            case Monosaccharide.Gal:
                if (ValidAddGal())
                {
                    List <NGlycanComplex> gs = CreateByAddGal();
                    glycans.AddRange(gs);
                }
                break;

            case Monosaccharide.Fuc:
                if (ValidAddFucCore())
                {
                    NGlycanComplex ptr = CreateByAddFucCore();
                    glycans.Add(ptr);
                }
                if (ValidAddFucTerminal())
                {
                    List <NGlycanComplex> gs = CreateByAddFucTerminal();
                    glycans.AddRange(gs);
                }
                break;

            case Monosaccharide.NeuAc:
                if (ValidAddNeuAc())
                {
                    List <NGlycanComplex> gs = CreateByAddNeuAc();
                    glycans.AddRange(gs);
                }
                break;

            case Monosaccharide.NeuGc:
                if (ValidAddNeuGc())
                {
                    List <NGlycanComplex> gs = CreateByAddNeuGc();
                    glycans.AddRange(gs);
                }
                break;

            default:
                break;
            }
            return(glycans);
        }