コード例 #1
0
        //functions for making openbabel easier to work with, adding functionality that isn't in the api(also adding functionality that is in the regular api, but isn't in the C# api), and functions that make debugging less of a pain
        //this is in a partial class for now, but it would be pretty useful as a library

        #region functions for converting double arrays to their openbabel counterparts and vice versa

        public static double[] obvec2dubs(OBVector3 a)
        {
            //turns a horrible obvector into a very nice double array

            double[] b = { a.GetX(), a.GetY(), a.GetZ() };
            return(b);
        }
コード例 #2
0
//        public static bool isInCone(OBVector3 x, OBVector3 apex, OBVector3 axis, double aperture )
//        {
//            //got it from here:http://stackoverflow.com/questions/10768142/verify-if-point-is-inside-a-cone-in-3d-space
//            //test if point x is inside an infinite cone defined by apex point with normal vector axis and aperture angle(in radians)
//            double halfAperture=aperture/2;
//            OBVector3 apexToXVect = OBVector3(apex,x);
//            OBVector3.
//            bool insideCone = StarMath.dotProduct(apex,axis)/StarMath.norm2(apexToXVect)/StarMath.norm2(axis) > Math.Cos(aperture);
//            return insideCone;
//        }
        public static bool atomsInCarboxylateCone(OBAtom a, OBAtom carba, OBMol mol)
        {
            //angle should probably not be hardcoded
            double aperture = 120 * Math.PI / 180;

            double[] axis = obvec2dubs(OBVector3.Sub(carba.GetVector(), a.GetVector()));
            //axis = StarMath.divide (axis, StarMath.norm2 (axis));
            double[]    apex    = obvec2dubs(carba.GetVector());
            List <uint> exclude = new List <uint>();

            exclude.Add(carba.GetIdx());
            foreach (OBBond b in carba.Bonds())
            {
                OBAtom other = b.GetNbrAtom(carba);
                if (other != a)
                {
                    exclude.Add(other.GetIdx());
                }
            }
            foreach (OBAtom n in mol.Atoms())
            {
                if (!exclude.Contains(n.GetIdx()))
                {
                    double[] x = obvec2dubs(n.GetVector());
                    //if any point is found to be in the carboxylate's cone, return true
                    if (isInCone(x, apex, axis, aperture))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
コード例 #3
0
        public static double radial_weight(OBMol mol, OBAtom carbon1, OBAtom a1)
        {
            OBVector3 compos = mol_com(mol);
            OBVector3 v2     = carbon1.GetVector();
            OBVector3 v3     = a1.GetVector();

            return(openbabel_csharp.Point2Line(compos, v2, v3));
        }
コード例 #4
0
        public static double atomdist(OBAtom a0, OBAtom a1)
        {
            OBVector3 disp = OBVector3.Sub(a0.GetVector(), a1.GetVector());
            double    x    = disp.GetX();
            double    y    = disp.GetY();
            double    z    = disp.GetZ();
            double    dist = Math.Sqrt(x * x + y * y + z * z);

            return(dist);
        }
コード例 #5
0
        public static double atom2linedistance(OBAtom x0, OBAtom a1, OBAtom a2)
        {
            //a1 and a2 are atoms that define the axis in question, x0 is the atom that we want to know the distance from the axis

            OBVector3 v0 = x0.GetVector();
            OBVector3 v1 = a1.GetVector();
            OBVector3 v2 = a2.GetVector();

            return(openbabel_csharp.Point2Line(v0, v1, v2));
        }
コード例 #6
0
        public static double pairwiseangle(OBAtom carbon1, OBAtom a1, OBAtom carbon2, OBAtom a2)
        {
            //carbon1 and carbon2 are carbon atoms connected to oxygen
            //a1 and a2 connect to carbon1 and carbon2 respectively

            OBVector3 vec1  = OBVector3.Sub(carbon1.GetVector(), a1.GetVector());
            OBVector3 vec2  = OBVector3.Sub(carbon2.GetVector(), a2.GetVector());
            double    angle = angle_between_vectors(vec1, vec2);

            return(angle);
        }
コード例 #7
0
        public static OBVector3 mol_com(OBMol mol)
        {
            //center of mass of molecule
            OBVector3 sum  = OBVector3.VZero;
            double    molw = 0;

            foreach (OBAtom a in mol.Atoms())
            {
                double m = a.GetAtomicMass();
                sum  = OBVector3.Add(sum, OBVector3.Mul(m, a.GetVector()));
                molw = molw + m;
            }

            return(OBVector3.Mul(1 / molw, sum));
        }
コード例 #8
0
        public static double angle_between_vectors(OBVector3 a, OBVector3 b)
        {
            a = a.Normalize();
            b = b.Normalize();

            double dot = StarMath.dotProduct(obvec2dubs(a), obvec2dubs(b));

            double angle = Math.Acos(dot) * 180 / Math.PI;

            if (double.IsNaN(angle))
            {
                angle = Math.Acos(Convert.ToInt32(dot)) * 180 / Math.PI;
            }
            return(angle);
        }
コード例 #9
0
        public static double greatest_radial_distance(OBMol mol, OBAtom carbon1, OBAtom a1)
        {
            OBVector3 v2   = carbon1.GetVector();
            OBVector3 v3   = a1.GetVector();
            double    maxd = 0;

            foreach (OBAtom a in mol.Atoms())
            {
                OBVector3 v1 = a.GetVector();
                double    d  = openbabel_csharp.Point2Line(v1, v2, v3);
                if (d > maxd)
                {
                    maxd = d;
                }
            }
            return(maxd);
        }
コード例 #10
0
 public static OBMol connect_within_radius(OBMol mol, OBAtom n, double radius)
 {
     foreach (OBAtom a in mol.Atoms())
     {
         if (a.GetIdx() == n.GetIdx())
         {
             continue;
         }
         else
         {
             double len = Math.Round(StarMath.norm2(obvec2dubs(OBVector3.Sub(a.GetVector(), n.GetVector()))),
                                     7); //gets length
             if (len <= radius)
             {
                 mol.AddBond((int)a.GetIdx(), (int)n.GetIdx(), 1);
             }
         }
     }
     return(mol);
 }
コード例 #11
0
        public static OBMol merge_atoms_at_same_location(OBMol mol)
        {
            double radius = 0.1;
            //when we make a unit_cell by copy and pasting base cases we end up with atoms at the same location that need to be merged
            //assumes only two atoms overlap at a time
            Dictionary <int, int> tomerge = new Dictionary <int, int>();

            foreach (OBAtom a in mol.Atoms())
            {
                if (!tomerge.ContainsKey((int)a.GetIdx()))
                {
                    foreach (OBAtom b in mol.Atoms())
                    {
                        if (a.GetIdx() == b.GetIdx())
                        {
                            continue;
                        }
                        else
                        {
                            double len =
                                Math.Round(StarMath.norm2(obvec2dubs(OBVector3.Sub(a.GetVector(), b.GetVector()))),
                                           7); //gets length
                            if (len <= radius)
                            {
                                tomerge.Add((int)b.GetIdx(), (int)a.GetIdx());
                            }
                        }
                    }
                }
            }
            int atomsdeleted = 0;

            foreach (int key in tomerge.Keys)
            {
                mol = molecule_merge(mol, mol.GetAtom(key - atomsdeleted), mol.GetAtom(tomerge[key] - atomsdeleted));
                atomsdeleted++;
            }
            return(mol);
        }
コード例 #12
0
        public static double greatest_axial_distance(OBMol mol, OBAtom carbon1, OBAtom a1)
        {
            //finds the distance of the most distant atom along the axis defined by the carboxyl defined by carbon 1 and a1
            double[] vec = obvec2dubs(OBVector3.Sub(carbon1.GetVector(), a1.GetVector()));
            vec = StarMath.normalize(vec);
            double maxd = 0;

            foreach (OBAtom a in mol.Atoms())
            {
                if (a == carbon1)
                {
                    continue;
                }
                double d = StarMath.dotProduct(vec,
                                               obvec2dubs(OBVector3.Sub(carbon1.GetVector(),
                                                                        a.GetVector()))); // get pairwise axial distance by taking the scalar projection of the carbon's position to atom A
                if (d > maxd)
                {
                    maxd = d;
                }
            }
            return(maxd);
        }
コード例 #13
0
        public static void trajectoryFrameToCIF(string frame, string outFile, List <int> esequence,
                                                OBConversion obconv)
        {
            //converts a frame from the above function into a CIF file
            //lammps trajectory files have unit cell dimension data for every frame
            //requires an element sequence for identifying element type from lammps atom types
            OBUnitCell  uc  = new OBUnitCell();
            OBMol       mol = new OBMol();
            OBMatrix3x3 mat = new OBMatrix3x3();

            using (StringReader reader = new StringReader(frame)) {
                string line        = "";
                bool   foundMatrix = false;

                do
                {
                    line = reader.ReadLine();
                    if (line.Contains("BOX BOUNDS"))
                    {
                        //data from lammps is in this format
                        //ITEM: BOX BOUNDS xy xz yz
                        //xlo_bound xhi_bound xy
                        //ylo_bound yhi_bound xz
                        //zlo_bound zhi_bound yz
                        string row0 = reader.ReadLine();

                        double[] row0d = OBFunctions.spacedStringToDoubleArray(row0);
                        double   xlo   = row0d[0];

                        double xhi = row0d[1];
                        double xy  = row0d[2];

                        string   row1  = reader.ReadLine();
                        double[] row1d = OBFunctions.spacedStringToDoubleArray(row1);
                        double   ylo   = row1d[0];
                        double   yhi   = row1d[1];
                        double   xz    = row1d[2];


                        string   row2  = reader.ReadLine();
                        double[] row2d = OBFunctions.spacedStringToDoubleArray(row2);
                        double   zlo   = row2d[0];
                        double   zhi   = row2d[1];
                        double   yz    = row2d[2];


                        //adjust box bounds, taken from VMD's source for reading lammps files

                        double xdelta = Math.Min(0, xy);
                        xdelta = Math.Min(xdelta, xz);
                        xdelta = Math.Min(xdelta, xy + xz);
                        xlo    = xlo - xdelta;
                        xdelta = Math.Max(0, xy);
                        xdelta = Math.Max(xdelta, xz);
                        xdelta = Math.Max(xdelta, xy + xz);
                        xhi    = xhi - xdelta;
                        ylo    = ylo - Math.Min(0, yz);
                        yhi    = yhi - Math.Max(0, yz);
                        OBVector3 A = new OBVector3(xhi - xlo, 0, 0);
                        OBVector3 B = new OBVector3(xy, yhi - ylo, 0);
                        OBVector3 C = new OBVector3(xz, yz, zhi - zlo);
                        //OBVector3 A = new OBVector3 (xhi-xlo, xy, xz);
                        //OBVector3 B = new OBVector3 (0, yhi-ylo, yz);
                        //OBVector3 C= new OBVector3 (0, 0, zhi-zlo);
                        mat = new OBMatrix3x3(A, B, C);
                        uc.SetData(A, B, C);

                        foundMatrix = true;
                    }
                } while (!foundMatrix);
                //uc.SetData (mat);
                bool foundAtoms = false;
                do
                {
                    line = reader.ReadLine();
                    if (line.Contains("ITEM: ATOMS"))
                    {
                        foundAtoms = true;
                    }
                } while (!foundAtoms);

                while ((line = reader.ReadLine()) != null)
                {
                    string[] splitline  = line.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
                    int      lammpstype = Convert.ToInt32(splitline[1]) - 1;
                    int      atype      = esequence[lammpstype];
                    OBAtom   a          = new OBAtom();
                    a.SetAtomicNum(atype);
                    //position in fraction coordinates
                    OBVector3 fvec = new OBVector3(Convert.ToDouble(splitline[3]), Convert.ToDouble(splitline[4]),
                                                   Convert.ToDouble(splitline[5]));
                    //OBVector3 fvec = new OBVector3 (Convert.ToDouble (splitline [2]), Convert.ToDouble (splitline [3]), Convert.ToDouble (splitline [4]));
                    //convert to cartesian.
                    OBVector3 cvec = uc.FractionalToCartesian(fvec);
                    a.SetVector(cvec);
                    mol.AddAtom(a);
                }

                mol.CloneData(uc);
                obconv.SetOutFormat("cif");
                obconv.AddOption("b");
                obconv.WriteFile(mol, outFile);
            }
        }
コード例 #14
0
        public static OBVector3 dubs2obvec(double[] a)
        {
            OBVector3 b = new OBVector3(a[0], a[1], a[2]);

            return(b);
        }