コード例 #1
0
ファイル: Symmetry.cs プロジェクト: lulzzz/ReciPro
 public bool IsPlaneRootIndex(int h, int k, int l) => SymmetryStatic.IsRootIndex(h, k, l, this);
コード例 #2
0
ファイル: ElasticityControl.cs プロジェクト: lulzzz/PDIndexer
        private void numericBoxElasticiry_ValueChanged(object sender, EventArgs e)
        {
            if (skip)
            {
                return;
            }
            if (((NumericBox)sender).Enabled == false)
            {
                return;
            }
            Symmetry tempSym = SymmetryStatic.Get_Symmetry(SymmetrySeriesNumber);

            switch (tempSym.CrystalSystemStr)
            {
            case "tetragonal":
                if (tempSym.PointGroupHMStr == "4" || tempSym.PointGroupHMStr == "-4" || tempSym.PointGroupHMStr == "4/m")
                {
                    numericBox22.Value = numericBox11.Value;
                    numericBox23.Value = numericBox13.Value;
                    numericBox26.Value = -numericBox16.Value;
                    numericBox55.Value = numericBox44.Value;
                }
                else
                {
                    numericBox22.Value = numericBox11.Value;
                    numericBox23.Value = numericBox13.Value;
                    numericBox55.Value = numericBox44.Value;
                }
                break;

            case "trigonal":
                if (tempSym.PointGroupHMStr == "3" || tempSym.PointGroupHMStr == "-3")
                {
                    numericBox22.Value = numericBox11.Value;
                    numericBox23.Value = numericBox13.Value;
                    numericBox24.Value = -numericBox14.Value;
                    numericBox25.Value = -numericBox15.Value;
                    numericBox46.Value = -numericBox15.Value;
                    numericBox56.Value = numericBox14.Value;
                    numericBox55.Value = numericBox44.Value;
                    numericBox66.Value = (numericBox11.Value - numericBox11.Value) / 2;
                }
                else
                {
                    numericBox22.Value = numericBox11.Value;
                    numericBox23.Value = numericBox13.Value;
                    numericBox24.Value = -numericBox14.Value;
                    numericBox56.Value = numericBox14.Value;
                    numericBox55.Value = numericBox44.Value;
                    numericBox66.Value = (numericBox11.Value - numericBox12.Value) / 2;
                }

                break;

            case "hexagonal":
                numericBox22.Value = numericBox11.Value;
                numericBox66.Value = (numericBox11.Value - numericBox12.Value) / 2;
                numericBox23.Value = numericBox13.Value;
                numericBox55.Value = numericBox44.Value;
                break;

            case "cubic":
                numericBox22.Value = numericBox33.Value = numericBox11.Value;
                numericBox55.Value = numericBox66.Value = numericBox44.Value;
                numericBox13.Value = numericBox23.Value = numericBox12.Value;
                break;
            }
            var mtx = new DenseMatrix(6, 6);

            mtx[0, 0] = mtx[0, 0] = numericBox11.Value;
            mtx[0, 1] = mtx[1, 0] = numericBox12.Value;
            mtx[0, 2] = mtx[2, 0] = numericBox13.Value;
            mtx[0, 3] = mtx[3, 0] = numericBox14.Value;
            mtx[0, 4] = mtx[4, 0] = numericBox15.Value;
            mtx[0, 5] = mtx[5, 0] = numericBox16.Value;

            mtx[1, 1] = numericBox22.Value;
            mtx[1, 2] = mtx[2, 1] = numericBox23.Value;
            mtx[1, 3] = mtx[3, 1] = numericBox24.Value;
            mtx[1, 4] = mtx[4, 1] = numericBox25.Value;
            mtx[1, 5] = mtx[5, 1] = numericBox26.Value;

            mtx[2, 2] = numericBox33.Value;
            mtx[2, 3] = mtx[3, 2] = numericBox34.Value;
            mtx[2, 4] = mtx[4, 2] = numericBox35.Value;
            mtx[2, 5] = mtx[5, 2] = numericBox36.Value;

            mtx[3, 3] = numericBox44.Value;
            mtx[3, 4] = mtx[4, 3] = numericBox45.Value;
            mtx[3, 5] = mtx[5, 3] = numericBox46.Value;

            mtx[4, 4] = numericBox55.Value;
            mtx[4, 5] = mtx[5, 4] = numericBox56.Value;

            mtx[5, 5] = numericBox66.Value;

            if (radioButtonStiffness.Checked)
            {
                stiffness  = mtx;
                compliance = mtx.TryInverse();
            }
            else
            {
                compliance = mtx;
                stiffness  = mtx.TryInverse();
            }
            if (ValueChanged != null)
            {
                ValueChanged(this, e);
            }
        }
コード例 #3
0
ファイル: ElasticityControl.cs プロジェクト: lulzzz/PDIndexer
        private void SetElasticity()
        {
            Symmetry tempSym = SymmetryStatic.Get_Symmetry(SymmetrySeriesNumber);

            //いったんすべてをEnabled=trueにする
            numericBox13.Enabled                 = numericBox23.Enabled =
                numericBox14.Enabled             = numericBox24.Enabled = numericBox34.Enabled =
                    numericBox15.Enabled         = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled =
                        numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled =
                            numericBox22.Enabled = numericBox33.Enabled = numericBox55.Enabled = numericBox66.Enabled = true;
            switch (tempSym.CrystalSystemStr)
            {
            case "Unknown": break;

            case "triclinic":
                break;

            case "monoclinic":
                switch (tempSym.MainAxis)
                {
                case "a":
                    numericBox15.Enabled         = numericBox25.Enabled = numericBox35.Enabled =
                        numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled =
                            numericBox45.Enabled = numericBox46.Enabled = false;

                    numericBox15.Value         = numericBox25.Value = numericBox35.Value =
                        numericBox16.Value     = numericBox26.Value = numericBox36.Value =
                            numericBox45.Value = numericBox46.Value = 0;
                    break;

                case "b":
                    numericBox14.Enabled         = numericBox24.Enabled = numericBox34.Enabled =
                        numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled =
                            numericBox45.Enabled = numericBox56.Enabled = false;

                    numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                        numericBox16.Value     = numericBox26.Value = numericBox36.Value =
                            numericBox45.Value = numericBox56.Value = 0;
                    break;

                case "c":
                    numericBox14.Enabled         = numericBox24.Enabled = numericBox34.Enabled =
                        numericBox15.Enabled     = numericBox25.Enabled = numericBox35.Enabled =
                            numericBox46.Enabled = numericBox56.Enabled = false;

                    numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                        numericBox15.Value     = numericBox25.Value = numericBox35.Value =
                            numericBox46.Value = numericBox56.Value = 0;
                    break;
                }
                break;

            case "orthorhombic":
                numericBox14.Enabled         = numericBox24.Enabled = numericBox34.Enabled =
                    numericBox15.Enabled     = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled =
                        numericBox16.Enabled = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled = false;

                numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                    numericBox15.Value     = numericBox25.Value = numericBox35.Value = numericBox45.Value =
                        numericBox16.Value = numericBox26.Value = numericBox36.Value = numericBox46.Value = numericBox56.Value = 0;
                break;

            case "tetragonal":
                if (tempSym.PointGroupHMStr == "4" || tempSym.PointGroupHMStr == "-4" || tempSym.PointGroupHMStr == "4/m")
                {
                    numericBox22.Enabled             = numericBox23.Enabled =
                        numericBox14.Enabled         = numericBox24.Enabled = numericBox34.Enabled =
                            numericBox15.Enabled     = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled = numericBox55.Enabled =
                                numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled = false;

                    numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                        numericBox15.Value     = numericBox25.Value = numericBox35.Value = numericBox45.Value =
                            numericBox36.Value = numericBox46.Value = numericBox56.Value = 0;
                }
                else
                {
                    numericBox22.Enabled         = numericBox23.Enabled = numericBox14.Enabled = numericBox24.Enabled = numericBox34.Enabled =
                        numericBox15.Enabled     = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled = numericBox55.Enabled =
                            numericBox16.Enabled = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled = false;

                    numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                        numericBox15.Value     = numericBox25.Value = numericBox35.Value = numericBox45.Value =
                            numericBox16.Value = numericBox26.Value = numericBox36.Value = numericBox46.Value = numericBox56.Value = 0;
                }
                break;

            case "trigonal":
                if (tempSym.PointGroupHMStr == "3" || tempSym.PointGroupHMStr == "-3")
                {
                    numericBox22.Enabled             = numericBox23.Enabled = numericBox24.Enabled = numericBox34.Enabled =
                        numericBox25.Enabled         = numericBox35.Enabled = numericBox45.Enabled = numericBox55.Enabled =
                            numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled =
                                numericBox66.Enabled = false;

                    numericBox34.Value     = numericBox35.Value = numericBox45.Value =
                        numericBox16.Value = numericBox26.Value = numericBox36.Value = 0;
                }
                else
                {
                    numericBox22.Enabled             = numericBox23.Enabled = numericBox24.Enabled = numericBox34.Enabled =
                        numericBox15.Enabled         = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled = numericBox55.Enabled =
                            numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled =
                                numericBox66.Enabled = false;

                    numericBox34.Value     = numericBox15.Value = numericBox25.Value = numericBox35.Value =
                        numericBox45.Value = numericBox16.Value = numericBox26.Value = numericBox36.Value = numericBox46.Value = 0;
                }
                break;

            case "hexagonal":
                numericBox22.Enabled             = numericBox23.Enabled = numericBox14.Enabled = numericBox24.Enabled = numericBox34.Enabled =
                    numericBox15.Enabled         = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled =
                        numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled =
                            numericBox55.Enabled = numericBox66.Enabled = false;

                numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                    numericBox15.Value     = numericBox25.Value = numericBox35.Value = numericBox45.Value =
                        numericBox16.Value = numericBox26.Value = numericBox36.Value = numericBox46.Value = numericBox56.Value = 0;
                break;

            case "cubic":
                numericBox13.Enabled             = numericBox23.Enabled = numericBox14.Enabled = numericBox24.Enabled = numericBox34.Enabled =
                    numericBox15.Enabled         = numericBox25.Enabled = numericBox35.Enabled = numericBox45.Enabled =
                        numericBox16.Enabled     = numericBox26.Enabled = numericBox36.Enabled = numericBox46.Enabled = numericBox56.Enabled =
                            numericBox22.Enabled = numericBox33.Enabled = numericBox55.Enabled = numericBox66.Enabled = false;

                numericBox14.Value         = numericBox24.Value = numericBox34.Value =
                    numericBox15.Value     = numericBox25.Value = numericBox35.Value = numericBox45.Value =
                        numericBox16.Value = numericBox26.Value = numericBox36.Value = numericBox46.Value = numericBox56.Value = 0;
                break;
            }
            numericBoxElasticiry_ValueChanged(numericBox11, new EventArgs());
        }
コード例 #4
0
        private void SetWyckoffPosition()
        {
            dataSet.Tables[0].Clear();
            if (Crystal.Symmetry.LatticeTypeStr == "P")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "", "", "" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "A")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(0,1/2,1/2)+", "", "" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "B")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(1/2,0,1/2)+", "", "" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "C")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(1/2,1/2,0)+", "", "" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "F")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(0,1/2,1/2)+", "(1/2,0,1/2)+", "(0,1/2,1/2)+" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "I")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(1/2,1/2,1/2)+", "", "" });
            }
            else if (Crystal.Symmetry.LatticeTypeStr == "H")
            {
                dataSet.Tables[0].Rows.Add(new object[] { "-", "-", "-", "(0,0,0)+", "(1/3,2/3,2/3)+", "(2/3,1/3,1/3)+", "" });
            }

            Crystal.Symmetry = SymmetryStatic.Get_Symmetry(Crystal.SymmetrySeriesNumber);

            for (int i = 0; i < SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber].Length; i++)
            {
                int len = SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr.Length;
                for (int j = 0; j < len; j += 4)
                {
                    object[] o;
                    if (j == 0)
                    {
                        o = new object[] {
                            SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].Multiplicity,
                            SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].WyckoffLetter,
                            SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].SiteSymmetry,
                            j < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j] : "",
                            j + 1 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 1] : "",
                            j + 2 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 2] : "",
                            j + 3 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 3] : ""
                        };
                    }
                    else
                    {
                        o = new object[] {
                            "",
                            "",
                            "",
                            j < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j] : "",
                            j + 1 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 1] : "",
                            j + 2 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 2] : "",
                            j + 3 < len ? SymmetryStatic.WyckoffPositions[Crystal.SymmetrySeriesNumber][i].PositionStr[j + 3] : ""
                        };
                    }

                    dataSet.Tables[0].Rows.Add(o);
                }
            }
        }
コード例 #5
0
        //回折斑点のパターンから晶帯軸を探す 1枚の写真から Mode1 2辺と間の角度

        public static ZoneAxis[] GetZoneAxis(Crystal cry, PhotoInformation photo, bool excludeEquivalence)
        {
            List <ZoneAxis> za = new List <ZoneAxis>();

            if (!photo.Paintable)
            {
                return(za.ToArray());
            }

            cry.SetPlanes(
                double.MaxValue, photo.IsTriangleMode ? Math.Min(Math.Min(photo.d1min, photo.d2min), photo.d3min) : Math.Min(photo.d1min, photo.d2min),
                false, false, false, false, 0, 0, 0);

            Plane[] plane = cry.Plane.ToArray();
            for (int n1 = 0; n1 < plane.Length; n1++)
            {
                if (!excludeEquivalence || plane[n1].IsRootIndex)
                {
                    if (plane[n1].d > photo.d1min && plane[n1].d < photo.d1max)
                    {
                        for (int n2 = 0; n2 < plane.Length; n2++)
                        {
                            if (plane[n2].d > photo.d2min && plane[n2].d < photo.d2max)
                            {
                                ZoneAxis tempZoneAxis = new ZoneAxis(cry, plane[n1], plane[n2], photo.Tilt1, photo.Tilt2);
                                if ((photo.IsTriangleMode && tempZoneAxis.plane3.d > photo.d3min && tempZoneAxis.plane3.d < photo.d3max) ||
                                    (!photo.IsTriangleMode && tempZoneAxis.Theta < photo.Theta + photo.theta_err && tempZoneAxis.Theta > photo.Theta - photo.theta_err))
                                {
                                    for (int z = 2; z <= Math.Abs(tempZoneAxis.u) || z <= Math.Abs(tempZoneAxis.v) || z <= Math.Abs(tempZoneAxis.w); z++)//最大公約数で割る
                                    {
                                        if ((tempZoneAxis.u % z == 0) && (tempZoneAxis.v % z == 0) && (tempZoneAxis.w % z == 0))
                                        {
                                            tempZoneAxis.u = tempZoneAxis.u / z; tempZoneAxis.v = tempZoneAxis.v / z; tempZoneAxis.w = tempZoneAxis.w / z; z = 1;
                                        }
                                    }
                                    za.Add(tempZoneAxis);
                                }
                            }
                        }
                    }
                }
            }
            //excludeEquivalence==true のとき、zaの中で等価なものを削除する
            if (excludeEquivalence)
            {
                for (int i = 0; i < za.Count; i++)
                {
                    for (int j = i + 1; j < za.Count; j++)
                    {
                        if (SymmetryStatic.CheckEquivalentAxes(za[i].u, za[i].v, za[i].w, za[j].u, za[j].v, za[j].w, cry.Symmetry))
                        {
                            if (za[i].plane1.h == za[j].plane1.h && za[i].plane1.k == za[j].plane1.k && za[i].plane1.l == za[j].plane1.l)
                            {
                                if (SymmetryStatic.CheckEquivalentPlanes(za[i].plane2.h, za[i].plane2.k, za[i].plane2.l, za[j].plane2.h, za[j].plane2.k, za[j].plane2.l, cry.Symmetry))
                                {
                                    za.RemoveAt(j);
                                    j--;
                                }
                            }
                        }
                    }
                }
            }
            return(za.ToArray());
        }
コード例 #6
0
        public static ZoneAxes[] ZoneAxisFromTwoZoneAxis(Crystal cry, PhotoInformation photo1, PhotoInformation photo2, bool excludeEquivalence)
        {
            //ここからホルダー間の角度上限下限をきめる
            double angleMax = 0, angleMin = 0;
            int    sign1 = Math.Sign(photo1.Tilt1 - photo2.Tilt1);
            int    sign2 = Math.Sign(photo1.Tilt2 - photo2.Tilt2);

            if (sign1 == 0)
            {
                sign1 = 1;
            }
            if (sign2 == 0)
            {
                sign2 = 1;
            }

            angleMax = GetAngleBetweenHolders(
                photo1.Tilt1 + sign1 * photo1.Tilt1Err, photo1.Tilt2 + sign2 * photo1.Tilt2Err,
                photo2.Tilt1 - sign1 * photo2.Tilt1Err, photo2.Tilt2 - sign2 * photo2.Tilt2Err);

            double p1t1, p1t2, p2t1, p2t2;

            if (Math.Sign((photo1.Tilt1 - sign1 * photo1.Tilt1Err) - (photo2.Tilt1 + sign1 * photo2.Tilt1Err)) != sign1)
            {
                p1t1 = p2t1 = (photo1.Tilt1 + photo2.Tilt1) / 2;
            }
            else
            {
                p1t1 = photo1.Tilt1 - sign1 * photo1.Tilt1Err;
                p2t1 = photo2.Tilt1 + sign1 * photo2.Tilt1Err;
            }
            if (Math.Sign((photo1.Tilt2 - sign2 * photo1.Tilt2Err) - (photo2.Tilt2 + sign2 * photo2.Tilt2Err)) != sign2)
            {
                p1t2 = p2t2 = (photo1.Tilt2 + photo2.Tilt2) / 2;
            }
            else
            {
                p1t2 = photo1.Tilt2 - sign2 * photo1.Tilt2Err;
                p2t2 = photo2.Tilt2 + sign2 * photo2.Tilt2Err;
            }
            angleMin = GetAngleBetweenHolders(p1t1, p1t2, p2t1, p2t2);

            //ここから条件にある軸のペアを検索
            List <ZoneAxes> zoneAxes = new List <ZoneAxes>();

            ZoneAxis[] zoneAxis1 = GetZoneAxis(cry, photo1, excludeEquivalence);
            ZoneAxis[] zoneAxis2 = GetZoneAxis(cry, photo2, false);
            for (int n = 0; n < zoneAxis1.Length; n++)
            {
                //if (zoneAxis1[n].plane1.IsRootIndex)
                for (int m = 0; m < zoneAxis2.Length; m++)
                {
                    Vector3D v1        = zoneAxis1[n].u * cry.A_Axis + zoneAxis1[n].v * cry.B_Axis + zoneAxis1[n].w * cry.C_Axis;
                    Vector3D v2        = zoneAxis2[m].u * cry.A_Axis + zoneAxis2[m].v * cry.B_Axis + zoneAxis2[m].w * cry.C_Axis;
                    double   calcAngle = Vector3D.AngleBetVectors(v1, v2);
                    if (angleMax >= calcAngle && angleMin <= calcAngle)
                    {
                        ZoneAxes temp = new ZoneAxes();
                        temp.Za1        = zoneAxis1[n];
                        temp.Za2        = zoneAxis2[m];
                        temp.AngleBet12 = calcAngle;
                        temp.IsTwoPhoho = true;
                        zoneAxes.Add(temp);
                    }
                }
            }
            //excludeEquivalence==true のとき、zoneAxesの中で等価なものを削除する
            if (excludeEquivalence)
            {
                for (int i = 0; i < zoneAxes.Count; i++)
                {
                    for (int j = i + 1; j < zoneAxes.Count; j++)
                    {
                        if (zoneAxes[i].Za1 == zoneAxes[j].Za1)
                        {
                            Plane plane1   = zoneAxes[i].Za2.plane1;
                            Plane plane2   = zoneAxes[i].Za2.plane2;
                            var   indices1 = new List <(int H, int K, int L)>();
                            var   indices2 = new List <(int H, int K, int L)>();
                            SymmetryStatic.IsRootIndex(plane1.h, plane1.k, plane1.l, cry.Symmetry, ref indices1, true);
                            SymmetryStatic.IsRootIndex(plane2.h, plane2.k, plane2.l, cry.Symmetry, ref indices2, true);

                            if (indices1.Contains((zoneAxes[j].Za2.plane1.h, zoneAxes[j].Za2.plane1.k, zoneAxes[j].Za2.plane1.l)) &&
                                indices2.Contains((zoneAxes[j].Za2.plane2.h, zoneAxes[j].Za2.plane2.k, zoneAxes[j].Za2.plane2.l)))
                            {
                                zoneAxes.RemoveAt(j);
                                j--;
                            }
                        }
                    }
                }
            }

            return(zoneAxes.ToArray());
        }