Ejemplo n.º 1
0
 /// <summary> Constructs an Atom from a String containing an element symbol.
 ///
 /// </summary>
 /// <param name="elementSymbol"> The String describing the element for the Atom
 /// </param>
 public Atom(System.String elementSymbol)
     : base(elementSymbol)
 {
     this.fractionalPoint3d = null;
     this.point3d           = null;
     this.point2d           = null;
 }
Ejemplo n.º 2
0
        /// <summary> Takes the given Z Matrix coordinates and converts them to cartesian coordinates.
        /// The first Atom end up in the origin, the second on on the x axis, and the third
        /// one in the XY plane. The rest is added by applying the Zmatrix distances, angles
        /// and dihedrals.
        /// 
        /// </summary>
        /// <param name="distances">    Array of distance variables of the Z matrix
        /// </param>
        /// <param name="angles">       Array of angle variables of the Z matrix
        /// </param>
        /// <param name="dihedrals">    Array of distance variables of the Z matrix
        /// </param>
        /// <param name="first_atoms">  Array of atom ids of the first involed atom in distance, angle and dihedral
        /// </param>
        /// <param name="second_atoms"> Array of atom ids of the second involed atom in angle and dihedral
        /// </param>
        /// <param name="third_atoms">  Array of atom ids of the third involed atom in dihedral
        /// 
        /// </param>
        /// <cdk.dictref>  blue-obelisk:zmatrixCoordinatesIntoCartesianCoordinates </cdk.dictref>
        public static Point3d[] zmatrixToCartesian(double[] distances, int[] first_atoms, double[] angles, int[] second_atoms, double[] dihedrals, int[] third_atoms)
        {
            Point3d[] cartesianCoords = new Point3d[distances.Length];
            for (int index = 0; index < distances.Length; index++)
            {
                if (index == 0)
                {
                    cartesianCoords[index] = new Point3d(0d, 0d, 0d);
                }
                else if (index == 1)
                {
                    cartesianCoords[index] = new Point3d(distances[1], 0d, 0d);
                }
                else if (index == 2)
                {
                    cartesianCoords[index] = new Point3d((-System.Math.Cos((angles[2] / 180) * System.Math.PI)) * distances[2] + distances[1], System.Math.Sin((angles[2] / 180) * System.Math.PI) * distances[2], 0d);
                }
                else
                {
                    Vector3d cd = new Vector3d();
                    cd.sub(cartesianCoords[third_atoms[index]], cartesianCoords[second_atoms[index]]);

                    Vector3d bc = new Vector3d();
                    bc.sub(cartesianCoords[second_atoms[index]], cartesianCoords[first_atoms[index]]);

                    Vector3d n1 = new Vector3d();
                    n1.cross(cd, bc);
                    n1.normalize();

                    Vector3d n2 = rotate(n1, bc, dihedrals[index]);
                    n2.normalize();
                    Vector3d ba = rotate(bc, n2, -angles[index]);

                    ba.normalize();

                    Vector3d ban = new Vector3d(ba);
                    ban.scale(distances[index]);

                    Point3d result = new Point3d();
                    result.add(cartesianCoords[first_atoms[index]], ba);
                    cartesianCoords[index] = result;
                }
            }
            return cartesianCoords;
        }
 /// <deprecated>
 /// </deprecated>
 public static Point3d fractionalToCartesian(double[] aAxis, double[] bAxis, double[] cAxis, Point3d fracPoint)
 {
     double[] frac = new double[3];
     frac[0] = fracPoint.x;
     frac[1] = fracPoint.y;
     frac[2] = fracPoint.z;
     double[] cart = fractionalToCartesian(aAxis, bAxis, cAxis, frac);
     return new Point3d(cart[0], cart[1], cart[2]);
 }
Ejemplo n.º 4
0
 /// <summary> Constructs an Atom from an Element and a Point3d.
 /// 
 /// </summary>
 /// <param name="elementSymbol">  The symbol of the atom
 /// </param>
 /// <param name="point3d">        The 3D coordinates of the atom
 /// </param>
 public Atom(System.String elementSymbol, javax.vecmath.Point3d point3d)
     : this(elementSymbol)
 {
     this.point3d = point3d;
 }
Ejemplo n.º 5
0
 /// <summary>
 /// Sets a point specifying the location of this
 /// atom in 3D space.
 ///
 /// </summary>
 /// <param name="point3d"> A point in a 3-dimensional space
 ///
 /// </param>
 /// <seealso cref="getPoint3d">
 /// </seealso>
 public virtual void setPoint3d(javax.vecmath.Point3d point3d)
 {
     this.point3d = point3d;
     notifyChanged();
 }
Ejemplo n.º 6
0
        /// <summary> Rotates a 3D point about a specified line segment by a specified angle.
        /// 
        /// The code is based on code available <a href="http://astronomy.swin.edu.au/~pbourke/geometry/rotate/source.c">here</a>.
        /// Positive angles are anticlockwise looking down the axis towards the origin.
        /// Assume right hand coordinate system.
        /// 
        /// </summary>
        /// <param name="atom">The atom to rotate
        /// </param>
        /// <param name="p1"> The  first point of the line segment
        /// </param>
        /// <param name="p2"> The second point of the line segment
        /// </param>
        /// <param name="angle"> The angle to rotate by (in degrees)
        /// </param>
        public static void rotate(IAtom atom, Point3d p1, Point3d p2, double angle)
        {
            double costheta, sintheta;

            Point3d r = new Point3d();

            r.x = p2.x - p1.x;
            r.y = p2.y - p1.y;
            r.z = p2.z - p1.z;
            normalize(r);


            angle = angle * System.Math.PI / 180.0;
            costheta = System.Math.Cos(angle);
            sintheta = System.Math.Sin(angle);

            Point3d p = atom.getPoint3d();
            p.x -= p1.x;
            p.y -= p1.y;
            p.z -= p1.z;

            Point3d q = new Point3d(0, 0, 0);
            q.x += (costheta + (1 - costheta) * r.x * r.x) * p.x;
            q.x += ((1 - costheta) * r.x * r.y - r.z * sintheta) * p.y;
            q.x += ((1 - costheta) * r.x * r.z + r.y * sintheta) * p.z;

            q.y += ((1 - costheta) * r.x * r.y + r.z * sintheta) * p.x;
            q.y += (costheta + (1 - costheta) * r.y * r.y) * p.y;
            q.y += ((1 - costheta) * r.y * r.z - r.x * sintheta) * p.z;

            q.z += ((1 - costheta) * r.x * r.z - r.y * sintheta) * p.x;
            q.z += ((1 - costheta) * r.y * r.z + r.x * sintheta) * p.y;
            q.z += (costheta + (1 - costheta) * r.z * r.z) * p.z;

            q.x += p1.x;
            q.y += p1.y;
            q.z += p1.z;

            atom.setPoint3d(q);
        }
 public virtual IAtom newAtom(String elementSymbol, Point3d point3d)
 {
     return new Atom(elementSymbol, point3d);
 }
Ejemplo n.º 8
0
        private IChemFile readChemFile(IChemFile file)
        {
            IChemSequence seq = file.Builder.newChemSequence();
            IChemModel model = file.Builder.newChemModel();
            ICrystal crystal = null;

            int lineNumber = 0;
            Vector3d a, b, c;

            try
            {
                System.String line = input.ReadLine();
                while (input.Peek() != -1 && line != null)
                {
                    //logger.debug((lineNumber++) + ": ", line);
                    if (line.StartsWith("frame:"))
                    {
                        //logger.debug("found new frame");
                        model = file.Builder.newChemModel();
                        crystal = file.Builder.newCrystal();

                        // assume the file format is correct

                        //logger.debug("reading spacegroup");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        crystal.SpaceGroup = line;

                        //logger.debug("reading unit cell axes");
                        Vector3d axis = new Vector3d();
                        //logger.debug("parsing A: ");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.x = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.y = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.z = FortranFormat.atof(line);
                        crystal.A = axis;
                        axis = new Vector3d();
                        //logger.debug("parsing B: ");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.x = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.y = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.z = FortranFormat.atof(line);
                        crystal.B = axis;
                        axis = new Vector3d();
                        //logger.debug("parsing C: ");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.x = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.y = FortranFormat.atof(line);
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        axis.z = FortranFormat.atof(line);
                        crystal.C = axis;
                        //logger.debug("Crystal: ", crystal);
                        a = crystal.A;
                        b = crystal.B;
                        c = crystal.C;

                        //logger.debug("Reading number of atoms");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        int atomsToRead = System.Int32.Parse(line);

                        //logger.debug("Reading no molecules in assym unit cell");
                        line = input.ReadLine();
                        //logger.debug((lineNumber++) + ": ", line);
                        int Z = System.Int32.Parse(line);
                        crystal.Z = Z;

                        System.String symbol;
                        double charge;
                        Point3d cart;
                        for (int i = 1; i <= atomsToRead; i++)
                        {
                            cart = new Point3d();
                            line = input.ReadLine();
                            //logger.debug((lineNumber++) + ": ", line);
                            symbol = line.Substring(0, (line.IndexOf(":")) - (0));
                            charge = System.Double.Parse(line.Substring(line.IndexOf(":") + 1));
                            line = input.ReadLine();
                            //logger.debug((lineNumber++) + ": ", line);
                            cart.x = System.Double.Parse(line); // x
                            line = input.ReadLine();
                            //logger.debug((lineNumber++) + ": ", line);
                            cart.y = System.Double.Parse(line); // y
                            line = input.ReadLine();
                            //logger.debug((lineNumber++) + ": ", line);
                            cart.z = System.Double.Parse(line); // z
                            IAtom atom = file.Builder.newAtom(symbol);
                            atom.setCharge(charge);
                            // convert cartesian coords to fractional
                            Point3d frac = CrystalGeometryTools.cartesianToFractional(a, b, c, cart);
                            atom.setFractionalPoint3d(frac);
                            crystal.addAtom(atom);
                            //logger.debug("Added atom: ", atom);
                        }

                        model.Crystal = crystal;
                        seq.addChemModel(model);
                    }
                    else
                    {
                        //logger.debug("Format seems broken. Skipping these lines:");
                        while (!line.StartsWith("frame:") && input.Peek() != -1 && line != null)
                        {
                            line = input.ReadLine();
                            //logger.debug(lineNumber++ + ": ", line);
                        }
                        //logger.debug("Ok, resynched: found new frame");
                    }
                }
                file.addChemSequence(seq);
            }
            catch (System.Exception exception)
            {
                //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                System.String message = "Error while parsing CrystClust file: " + exception.Message;
                //logger.error(message);
                //logger.debug(exception);
                throw new CDKException(message, exception);
            }
            return file;
        }
Ejemplo n.º 9
0
		/// <summary> Returns the distance between this point and point p1.</summary>
		/// <param name="p1">the other point
		/// </param>
		/// <returns> the distance 
		/// </returns>
		public double distance(Point3d p1)
		{
			double dx, dy, dz;
			
			dx = this.x - p1.x;
			dy = this.y - p1.y;
			dz = this.z - p1.z;
			return System.Math.Sqrt(dx * dx + dy * dy + dz * dz);
		}
Ejemplo n.º 10
0
		/// <summary> Transforms the point parameter with this Matrix4d and
		/// places the result back into point.  The fourth element of the
		/// point input paramter is assumed to be one.
		/// </summary>
		/// <param name="point">the input point to be transformed.
		/// </param>
		public void  transform(Point3d point)
		{
			transform(point, point);
		}
Ejemplo n.º 11
0
		/// <summary> Transforms the point parameter with this Matrix4d and places the result
		/// into pointOut. The fourth element of the point input paramter is assumed
		/// to be one.
		/// </summary>
		/// <param name="point">the input point to be transformed.
		/// </param>
		/// <param name="pointOut">the transformed point
		/// </param>
		public void  transform(Point3d point, Point3d pointOut)
		{
			pointOut.set_Renamed(m00 * point.x + m01 * point.y + m02 * point.z + m03, m10 * point.x + m11 * point.y + m12 * point.z + m13, m20 * point.x + m21 * point.y + m22 * point.z + m23);
		}
Ejemplo n.º 12
0
 /// <summary> Sets a point specifying the location of this
 /// atom in a Crystal unit cell.
 /// 
 /// </summary>
 /// <param name="point3d"> A point in a 3d fractional unit cell space
 /// 
 /// </param>
 /// <seealso cref="getFractionalPoint3d">
 /// </seealso>
 /// <seealso cref="org.openscience.cdk.Crystal">
 /// </seealso>
 public virtual void setFractionalPoint3d(javax.vecmath.Point3d point3d)
 {
     this.fractionalPoint3d = point3d;
     notifyChanged();
 }
Ejemplo n.º 13
0
 /// <summary> 
 /// Sets a point specifying the location of this
 /// atom in 3D space.
 /// 
 /// </summary>
 /// <param name="point3d"> A point in a 3-dimensional space
 /// 
 /// </param>
 /// <seealso cref="getPoint3d">
 /// </seealso>
 public virtual void setPoint3d(javax.vecmath.Point3d point3d)
 {
     this.point3d = point3d;
     notifyChanged();
 }
Ejemplo n.º 14
0
 /// <cdk.dictref>  blue-obelisk:convertCartesianIntoFractionalCoordinates </cdk.dictref>
 public static Point3d cartesianToFractional(Vector3d aAxis, Vector3d bAxis, Vector3d cAxis, Point3d cartPoint)
 {
     Vector3d[] invaxis = calcInvertedAxes(aAxis, bAxis, cAxis);
     Point3d frac = new Point3d();
     frac.x = invaxis[0].x * cartPoint.x + invaxis[0].y * cartPoint.y + invaxis[0].z * cartPoint.z;
     frac.y = invaxis[1].x * cartPoint.x + invaxis[1].y * cartPoint.y + invaxis[1].z * cartPoint.z;
     frac.z = invaxis[2].x * cartPoint.x + invaxis[2].y * cartPoint.y + invaxis[2].z * cartPoint.z;
     return frac;
 }
Ejemplo n.º 15
0
		/// <summary> Computes the L-1 (Manhattan) distance between this point and
		/// point p1.  The L-1 distance is equal to:
		/// abs(x1-x2) + abs(y1-y2) + abs(z1-z2).
		/// </summary>
		/// <param name="p1">the other point
		/// </param>
		/// <returns>  the L-1 distance
		/// </returns>
		public double distanceL1(Point3d p1)
		{
			return System.Math.Abs(this.x - p1.x) + System.Math.Abs(this.y - p1.y) + System.Math.Abs(this.z - p1.z);
		}
Ejemplo n.º 16
0
        private void processAtomLoopBlock(System.String firstLine)
        {
            int atomLabel = -1; // -1 means not found in this block
            int atomSymbol = -1;
            int atomFractX = -1;
            int atomFractY = -1;
            int atomFractZ = -1;
            int atomRealX = -1;
            int atomRealY = -1;
            int atomRealZ = -1;
            System.String line = firstLine.Trim();
            int headerCount = 0;
            bool hasParsableInformation = false;
            while (line != null && line[0] == '_')
            {
                headerCount++;
                if (line.Equals("_atom_site_label") || line.Equals("_atom_site_label_atom_id"))
                {
                    atomLabel = headerCount;
                    hasParsableInformation = true;
                    //logger.info("label found in col: " + atomLabel);
                }
                else if (line.StartsWith("_atom_site_fract_x"))
                {
                    atomFractX = headerCount;
                    hasParsableInformation = true;
                    //logger.info("frac x found in col: " + atomFractX);
                }
                else if (line.StartsWith("_atom_site_fract_y"))
                {
                    atomFractY = headerCount;
                    hasParsableInformation = true;
                    //logger.info("frac y found in col: " + atomFractY);
                }
                else if (line.StartsWith("_atom_site_fract_z"))
                {
                    atomFractZ = headerCount;
                    hasParsableInformation = true;
                    //logger.info("frac z found in col: " + atomFractZ);
                }
                else if (line.Equals("_atom_site.Cartn_x"))
                {
                    atomRealX = headerCount;
                    hasParsableInformation = true;
                    //logger.info("cart x found in col: " + atomRealX);
                }
                else if (line.Equals("_atom_site.Cartn_y"))
                {
                    atomRealY = headerCount;
                    hasParsableInformation = true;
                    //logger.info("cart y found in col: " + atomRealY);
                }
                else if (line.Equals("_atom_site.Cartn_z"))
                {
                    atomRealZ = headerCount;
                    hasParsableInformation = true;
                    //logger.info("cart z found in col: " + atomRealZ);
                }
                else if (line.Equals("_atom_site.type_symbol"))
                {
                    atomSymbol = headerCount;
                    hasParsableInformation = true;
                    //logger.info("type_symbol found in col: " + atomSymbol);
                }
                else
                {
                    //logger.warn("Ignoring atom loop block field: " + line);
                }
                line = input.ReadLine().Trim();
            }
            if (hasParsableInformation == false)
            {
                //logger.info("No parsable info found");
                skipUntilEmptyOrCommentLine(line);
            }
            else
            {
                // now that headers are parsed, read the data
                while (line != null && line.Length > 0 && line[0] != '#')
                {
                    //logger.debug("new row");
                    SupportClass.Tokenizer tokenizer = new SupportClass.Tokenizer(line);
                    if (tokenizer.Count < headerCount)
                    {
                        //logger.warn("Column count mismatch; assuming continued on next line");
                        //logger.debug("Found #expected, #found: " + headerCount + ", " + tokenizer.Count);
                        tokenizer = new SupportClass.Tokenizer(line + input.ReadLine());
                    }
                    int colIndex = 0;
                    // process one row
                    IAtom atom = crystal.Builder.newAtom("C");
                    Point3d frac = new Point3d();
                    Point3d real = new Point3d();
                    bool hasFractional = false;
                    bool hasCartesian = false;
                    while (tokenizer.HasMoreTokens())
                    {
                        colIndex++;
                        System.String field = tokenizer.NextToken();
                        //logger.debug("Parsing col,token: " + colIndex + "=" + field);
                        if (colIndex == atomLabel)
                        {
                            if (atomSymbol == -1)
                            {
                                // no atom symbol found, use label
                                System.String element = extractFirstLetters(field);
                                atom.Symbol = element;
                            }
                            atom.ID = field;
                        }
                        else if (colIndex == atomFractX)
                        {
                            hasFractional = true;
                            frac.x = parseIntoDouble(field);
                        }
                        else if (colIndex == atomFractY)
                        {
                            hasFractional = true;
                            frac.y = parseIntoDouble(field);
                        }
                        else if (colIndex == atomFractZ)
                        {
                            hasFractional = true;
                            frac.z = parseIntoDouble(field);
                        }
                        else if (colIndex == atomSymbol)
                        {
                            atom.Symbol = field;
                        }
                        else if (colIndex == atomRealX)
                        {
                            hasCartesian = true;
                            //logger.debug("Adding x3: " + parseIntoDouble(field));
                            real.x = parseIntoDouble(field);
                        }
                        else if (colIndex == atomRealY)
                        {
                            hasCartesian = true;
                            //logger.debug("Adding y3: " + parseIntoDouble(field));
                            real.y = parseIntoDouble(field);
                        }
                        else if (colIndex == atomRealZ)
                        {
                            hasCartesian = true;
                            //logger.debug("Adding x3: " + parseIntoDouble(field));
                            real.z = parseIntoDouble(field);
                        }
                    }
                    if (hasCartesian)
                    {
                        Vector3d a = crystal.A;
                        Vector3d b = crystal.B;
                        Vector3d c = crystal.C;
                        frac = CrystalGeometryTools.cartesianToFractional(a, b, c, real);
                        atom.setFractionalPoint3d(frac);
                    }
                    if (hasFractional)
                    {
                        atom.setFractionalPoint3d(frac);
                    }
                    //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
                    //logger.debug("Adding atom: " + atom);
                    crystal.addAtom(atom);

                    // look up next row
                    line = input.ReadLine().Trim();
                }
            }
        }
Ejemplo n.º 17
0
		/// <summary> Computes the L-infinite distance between this point and
		/// point p1.  The L-infinite distance is equal to
		/// MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2)].
		/// </summary>
		/// <param name="p1">the other point
		/// </param>
		/// <returns>  the L-infinite distance
		/// </returns>
		public double distanceLinf(Point3d p1)
		{
			double tmp;
			tmp = System.Math.Max(System.Math.Abs(this.x - p1.x), System.Math.Abs(this.y - p1.y));
			
			return System.Math.Max(tmp, System.Math.Abs(this.z - p1.z));
		}
 public virtual IPseudoAtom newPseudoAtom(String label, Point3d point3d)
 {
     return new PseudoAtom(label, point3d);
 }
Ejemplo n.º 19
0
		/// <summary> Constructs and initializes a Point3d from the specified Point3d.</summary>
		/// <param name="p1">the Point3d containing the initialization x y z data
		/// </param>
		public Point3d(Point3d p1):base(p1)
		{
		}
Ejemplo n.º 20
0
 /// <summary>  Returns the geometric center of all the atoms in this atomContainer.
 /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
 /// 
 /// </summary>
 /// <param name="ac"> Description of the Parameter
 /// </param>
 /// <returns>     the geometric center of the atoms in this atomContainer
 /// </returns>
 public static Point3d get3DCenter(IAtomContainer ac)
 {
     double centerX = 0;
     double centerY = 0;
     double centerZ = 0;
     double counter = 0;
     IAtom[] atoms = ac.Atoms;
     for (int i = 0; i < atoms.Length; i++)
     {
         if (atoms[i].getPoint3d() != null)
         {
             centerX += atoms[i].getPoint3d().x;
             centerY += atoms[i].getPoint3d().y;
             centerZ += atoms[i].getPoint3d().z;
             counter++;
         }
     }
     Point3d point = new Point3d(centerX / (counter), centerY / (counter), centerZ / (counter));
     return point;
 }
Ejemplo n.º 21
0
		/// <summary> Returns the square of the distance between this point and point p1.</summary>
		/// <param name="p1">the other point 
		/// </param>
		/// <returns> the square of the distance
		/// </returns>
		public double distanceSquared(Point3d p1)
		{
			double dx, dy, dz;
			
			dx = this.x - p1.x;
			dy = this.y - p1.y;
			dz = this.z - p1.z;
			return (dx * dx + dy * dy + dz * dz);
		}
Ejemplo n.º 22
0
 /// <summary> Normalizes a point.
 /// 
 /// </summary>
 /// <param name="point">The point to normalize
 /// </param>
 public static void normalize(Point3d point)
 {
     double sum = System.Math.Sqrt(point.x * point.x + point.y * point.y + point.z * point.z);
     point.x = point.x / sum;
     point.y = point.y / sum;
     point.z = point.z / sum;
 }
Ejemplo n.º 23
0
 public PDBAtom(System.String symbol, Point3d coordinate)
     : base(symbol, coordinate)
 {
     initValues();
 }
Ejemplo n.º 24
0
 /// <summary> Constructs an Atom from an Element and a Point3d.
 ///
 /// </summary>
 /// <param name="elementSymbol">  The symbol of the atom
 /// </param>
 /// <param name="point3d">        The 3D coordinates of the atom
 /// </param>
 public Atom(System.String elementSymbol, javax.vecmath.Point3d point3d)
     : this(elementSymbol)
 {
     this.point3d = point3d;
 }
Ejemplo n.º 25
0
 /// <cdk.dictref>  blue-obelisk:convertFractionIntoCartesianCoordinates </cdk.dictref>
 public static Point3d fractionalToCartesian(Vector3d aAxis, Vector3d bAxis, Vector3d cAxis, Point3d frac)
 {
     Point3d cart = new Point3d();
     cart.x = frac.x * aAxis.x + frac.y * bAxis.x + frac.z * cAxis.x;
     cart.y = frac.x * aAxis.y + frac.y * bAxis.y + frac.z * cAxis.y;
     cart.z = frac.x * aAxis.z + frac.y * bAxis.z + frac.z * cAxis.z;
     return cart;
 }
Ejemplo n.º 26
0
 /// <summary> Sets a point specifying the location of this
 /// atom in a Crystal unit cell.
 ///
 /// </summary>
 /// <param name="point3d"> A point in a 3d fractional unit cell space
 ///
 /// </param>
 /// <seealso cref="getFractionalPoint3d">
 /// </seealso>
 /// <seealso cref="org.openscience.cdk.Crystal">
 /// </seealso>
 public virtual void setFractionalPoint3d(javax.vecmath.Point3d point3d)
 {
     this.fractionalPoint3d = point3d;
     notifyChanged();
 }
Ejemplo n.º 27
0
 /// <summary> Constructs an Atom from a String containing an element symbol.
 /// 
 /// </summary>
 /// <param name="elementSymbol"> The String describing the element for the Atom
 /// </param>
 public Atom(System.String elementSymbol)
     : base(elementSymbol)
 {
     this.fractionalPoint3d = null;
     this.point3d = null;
     this.point2d = null;
 }