public void TestNotionalToCartesian_Double_double_double_double_double_double()
        {
            Vector3[] cardAxes = CrystalGeometryTools.NotionalToCartesian(1.0, 2.0, 3.0, 90.0, 90.0, 90.0);
            // the a axis
            Assert.AreEqual(1.0, cardAxes[0].X, 0.001);
            Assert.AreEqual(0.0, cardAxes[0].Y, 0.001);
            Assert.AreEqual(0.0, cardAxes[0].Z, 0.001);
            // the b axis
            Assert.AreEqual(0.0, cardAxes[1].X, 0.001);
            Assert.AreEqual(2.0, cardAxes[1].Y, 0.001);
            Assert.AreEqual(0.0, cardAxes[1].Z, 0.001);
            // the c axis
            Assert.AreEqual(0.0, cardAxes[2].X, 0.001);
            Assert.AreEqual(0.0, cardAxes[2].Y, 0.001);
            Assert.AreEqual(3.0, cardAxes[2].Z, 0.001);

            // some sanity checking: roundtripping
            cardAxes = CrystalGeometryTools.NotionalToCartesian(9.3323, 10.1989, 11.2477, 69.043, 74.441, 77.821);
            Vector3 a = cardAxes[0];
            Vector3 b = cardAxes[1];
            Vector3 c = cardAxes[2];

            Assert.AreEqual(69.043, Vectors.RadianToDegree(Vectors.Angle(b, c)), 0.001);
            Assert.AreEqual(74.441, Vectors.RadianToDegree(Vectors.Angle(a, c)), 0.001);
            Assert.AreEqual(77.821, Vectors.RadianToDegree(Vectors.Angle(b, a)), 0.001);
            Assert.AreEqual(9.3323, a.Length(), 0.0001);
            Assert.AreEqual(10.1989, b.Length(), 0.0001);
            Assert.AreEqual(11.2477, c.Length(), 0.0001);
        }
        public void TestCalcInvertedAxes_Vector3d_Vector3d_Vector3d()
        {
            Vector3 a = new Vector3(3.4, 7.6, 5.5);
            Vector3 b = new Vector3(2.8, 4.0, 6.3);
            Vector3 c = new Vector3(1.9, 3.9, 9.1);

            Vector3[] invertedAxes = CrystalGeometryTools.CalcInvertedAxes(a, b, c);
            Vector3   a2           = invertedAxes[0];
            Vector3   b2           = invertedAxes[1];
            Vector3   c2           = invertedAxes[2];

            Vector3[] doubleAxes = CrystalGeometryTools.CalcInvertedAxes(a2, b2, c2);
            Vector3   a3         = doubleAxes[0];
            Vector3   b3         = doubleAxes[1];
            Vector3   c3         = doubleAxes[2];

            Assert.AreEqual(a.X, a3.X, 0.001);
            Assert.AreEqual(a.Y, a3.Y, 0.001);
            Assert.AreEqual(a.Z, a3.Z, 0.001);
            Assert.AreEqual(b.X, b3.X, 0.001);
            Assert.AreEqual(b.Y, b3.Y, 0.001);
            Assert.AreEqual(b.Z, b3.Z, 0.001);
            Assert.AreEqual(c.X, c3.X, 0.001);
            Assert.AreEqual(c.Y, c3.Y, 0.001);
            Assert.AreEqual(c.Z, c3.Z, 0.001);
        }
        public void TestCartesianToFractional_Vector3d_Vector3d_Vector3d_Point3d()
        {
            Vector3 a          = new Vector3(1.0, 0.0, 0.0);
            Vector3 b          = new Vector3(0.0, 2.0, 0.0);
            Vector3 c          = new Vector3(0.0, 0.0, 3.0);
            Vector3 cartCoord  = new Vector3(0.25, 1.0, 2.25);
            Vector3 fractCoord = CrystalGeometryTools.CartesianToFractional(a, b, c, cartCoord);

            Assert.AreEqual(0.25, fractCoord.X, 0.001);
            Assert.AreEqual(0.50, fractCoord.Y, 0.001);
            Assert.AreEqual(0.75, fractCoord.Z, 0.001);
        }
        public void TestCartesianToNotional_Vector3d_Vector3d_Vector3d()
        {
            Vector3 a = new Vector3(1.0, 0.0, 0.0);
            Vector3 b = new Vector3(0.0, 2.0, 0.0);
            Vector3 c = new Vector3(0.0, 0.0, 3.0);

            double[] notionalCoords = CrystalGeometryTools.CartesianToNotional(a, b, c);
            Assert.AreEqual(1.0, notionalCoords[0], 0.001);
            Assert.AreEqual(2.0, notionalCoords[1], 0.001);
            Assert.AreEqual(3.0, notionalCoords[2], 0.001);
            Assert.AreEqual(90.0, notionalCoords[3], 0.001);
            Assert.AreEqual(90.0, notionalCoords[4], 0.001);
            Assert.AreEqual(90.0, notionalCoords[5], 0.001);
        }
        public void TestFractionalToCartesian2()
        {
            Vector3[] cardAxes = CrystalGeometryTools
                                 .NotionalToCartesian(9.3323, 10.1989, 11.2477, 69.043, 74.441, 77.821);
            Vector3 a = cardAxes[0];
            Vector3 b = cardAxes[1];
            Vector3 c = cardAxes[2];

            Vector3 cartCoords = CrystalGeometryTools.FractionalToCartesian(a, b, c, new Vector3(0.517879, 0.258121, 0.698477));

            Assert.AreEqual(7.495, cartCoords.X, 0.001);
            Assert.AreEqual(4.993, cartCoords.Y, 0.001);
            Assert.AreEqual(7.171, cartCoords.Z, 0.001);
        }
        public void TestRoundTripUnitCellNotionalCoordinates()
        {
            Vector3[] cardAxes = CrystalGeometryTools.NotionalToCartesian(7.6, 3.9, 10.3, 67.0, 91.2, 110.5);
            Vector3   a        = cardAxes[0];
            Vector3   b        = cardAxes[1];
            Vector3   c        = cardAxes[2];

            double[] notionalCoords = CrystalGeometryTools.CartesianToNotional(a, b, c);
            Assert.AreEqual(7.6, notionalCoords[0], 0.001);
            Assert.AreEqual(3.9, notionalCoords[1], 0.001);
            Assert.AreEqual(10.3, notionalCoords[2], 0.001);
            Assert.AreEqual(67.0, notionalCoords[3], 0.001);
            Assert.AreEqual(91.2, notionalCoords[4], 0.001);
            Assert.AreEqual(110.5, notionalCoords[5], 0.001);
        }