private IRenderingElement GenerateMixtureSgroup(Sgroup sgroup)
        {
            // draw the brackets
            // TODO - mixtures normally have attached Sgroup data
            // TODO - e.g. COMPONENT_FRACTION, ACTIVITY_TYPE, WEIGHT_PERCENT
            var brackets = (IList <SgroupBracket>)sgroup.GetValue(SgroupKey.CtabBracket);

            if (brackets != null)
            {
                SgroupType type      = sgroup.Type;
                string     subscript = "?";
                switch (type)
                {
                case SgroupType.CtabComponent:
                    var compNum = (int?)sgroup.GetValue(SgroupKey.CtabComponentNumber);
                    if (compNum != null)
                    {
                        subscript = "c" + compNum.ToString();
                    }
                    else
                    {
                        subscript = "c";
                    }
                    break;

                case SgroupType.CtabMixture:
                    subscript = "mix";
                    break;

                case SgroupType.CtabFormulation:
                    subscript = "f";
                    break;
                }

                return(GenerateSgroupBrackets(sgroup,
                                              brackets,
                                              null,
                                              subscript,
                                              null));
            }
            else
            {
                return(new ElementGroup());
            }
        }
示例#2
0
 public static string Key(this SgroupType value)
 => StrToSgroupTypeMap.Keys.ElementAt((int)value);
        /// <summary>
        /// Generates polymer Sgroup elements.
        /// </summary>
        /// <param name="sgroup">the Sgroup</param>
        /// <returns>the rendered elements (empty if no brackets defined)</returns>
        private IRenderingElement GeneratePolymerSgroup(Sgroup sgroup, IReadOnlyDictionary <IAtom, AtomSymbol> symbolMap)
        {
            // draw the brackets
            var brackets = (IList <SgroupBracket>)sgroup.GetValue(SgroupKey.CtabBracket);

            if (brackets != null)
            {
                SgroupType type = sgroup.Type;

                var subscript    = (string)sgroup.GetValue(SgroupKey.CtabSubScript);
                var connectivity = (string)sgroup.GetValue(SgroupKey.CtabConnectivity);

                switch (type)
                {
                case SgroupType.CtabCopolymer:
                    subscript = "co";
                    string subtype = (string)sgroup.GetValue(SgroupKey.CtabSubType);
                    if (string.Equals("RAN", subtype, StringComparison.Ordinal))
                    {
                        subscript = "ran";
                    }
                    else if (string.Equals("BLK", subtype, StringComparison.Ordinal))
                    {
                        subscript = "blk";
                    }
                    else if (string.Equals("ALT", subtype, StringComparison.Ordinal))
                    {
                        subscript = "alt";
                    }
                    break;

                case SgroupType.CtabCrossLink:
                    subscript = "xl";
                    break;

                case SgroupType.CtabAnyPolymer:
                    subscript = "any";
                    break;

                case SgroupType.CtabGraft:
                    subscript = "grf";
                    break;

                case SgroupType.CtabMer:
                    subscript = "mer";
                    break;

                case SgroupType.CtabMonomer:
                    subscript = "mon";
                    break;

                case SgroupType.CtabModified:
                    subscript = "mod";
                    break;

                case SgroupType.CtabStructureRepeatUnit:
                    if (subscript == null)
                    {
                        subscript = "n";
                    }
                    if (connectivity == null)
                    {
                        connectivity = "eu";
                    }
                    break;
                }

                // connectivity doesn't matter if symmetric... which is hard to test
                // here but we can certainly ignore it for single atoms (e.g. methylene)
                // also when we see brackets we presume head-to-tail repeating
                if ("ht".Equals(connectivity) || sgroup.Atoms.Count == 1)
                {
                    connectivity = null;
                }

                return(GenerateSgroupBrackets(sgroup,
                                              brackets,
                                              symbolMap,
                                              subscript,
                                              connectivity));
            }
            else
            {
                return(new ElementGroup());
            }
        }