Exemplo n.º 1
0
        public static bool[][] GetInterChainContactBools(IStructure structure)
        {
            // Identify inter-chain contacts and then map all aas in the structure to true/false
            Selection contactAas = Clash.GetContactSelection(structure.ToArray());

            bool[][] contacts = structure.Select(chain => chain.Select(aa => contactAas.Aas.Contains(aa)).ToArray()).ToArray();
            return(contacts);
        }
Exemplo n.º 2
0
        public static Selection GetContacts(IStructure structure)
        {
            Selection selection = Clash.GetContactSelection(structure.ToArray());

            return(selection);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Given a selection and two structures - an original and a cloned structure, returns a selection
        /// matching the original selection, but for the cloned structure
        /// </summary>
        /// <param name="template"></param>
        /// <param name="templateStructure"></param>
        /// <param name="cloneStructure"></param>
        /// <returns></returns>
        public static Selection Clone(Selection template, IStructure templateStructure, IStructure cloneStructure)
        {
            Selection result = new Selection();


            if (template.Structures.Contains(templateStructure))
            {
                result.Structures.Add(cloneStructure);
            }

            if (template.Atoms.Count == 0 && template.Aas.Count == 0 && template.Chains.Count == 0)
            {
                return(result);
            }

            IChain[] tChains = templateStructure.ToArray();
            IChain[] cChains = cloneStructure.ToArray();
            Trace.Assert(tChains.Length == cChains.Length);

            if (template.Chains.Count > 0)
            {
                for (int i = 0; i < tChains.Length; i++)
                {
                    if (template.Chains.Contains(tChains[i]))
                    {
                        result.Chains.Add(cChains[i]);
                    }
                }
            }

            if (template.Aas.Count == 0 && template.Atoms.Count == 0)
            {
                return(result);
            }

            IAa[] tAas = tChains.SelectMany(chain => chain).ToArray();
            IAa[] cAas = cChains.SelectMany(chain => chain).ToArray();
            Trace.Assert(tAas.Length == cAas.Length);

            if (template.Aas.Count > 0)
            {
                for (int i = 0; i < tAas.Length; i++)
                {
                    if (template.Aas.Contains(tAas[i]))
                    {
                        result.Aas.Add(cAas[i]);
                    }
                }
            }

            if (template.Atoms.Count == 0)
            {
                return(result);
            }

            IAtom[] tAtoms = tAas.SelectMany(aa => aa).ToArray();
            IAtom[] cAtoms = cAas.SelectMany(aa => aa).ToArray();
            Trace.Assert(tAtoms.Length == cAtoms.Length);

            for (int i = 0; i < tAtoms.Length; i++)
            {
                if (template.Atoms.Contains(tAtoms[i]))
                {
                    result.Atoms.Add(cAtoms[i]);
                }
            }

            return(result);
        }