Exemple #1
0
        private void getMesh()
        {
            double Alen = readDoubleFromTextBox(TB_A); //длина пластинки
            double Blen = readDoubleFromTextBox(TB_B); //ширина пластинки
            double Zlen = readDoubleFromTextBox(TB_H); //толщина пластинки
            double ZlenVn = readDoubleFromTextBox(TB_Hvn); //толщина внешних слоёв

            int xCnt = readIntFromTextBox(tb_x); //количество узлов по OX
            int yCnt = readIntFromTextBox(tb_y); //количество узлов по OY
            int zCnt = 4;//readIntFromTextBox(tb_z); //количество узлов по OZ

            int cntSloi = xCnt * yCnt; //количество узлов на слое
            obCountUzl = cntSloi * zCnt; //общее количество узлов модели

            int cntElemSloi = (xCnt - 1) * (yCnt - 1);//количество элементов на слое
            int countElem = cntElemSloi * (zCnt - 1) * 6; //общее количество элементов модели
            SLOI = cntElemSloi * 6;
            nodes = new Node[obCountUzl]; //массив всех узлов
            elements = new Element[countElem]; //массив конечных элементов

            double stepOX, //шаг по OX
                   stepOY; //шаг по OY

            double[] stepOZ = new double[4];
            //шаги по OZ
            stepOZ[0] = ZlenVn;
            stepOZ[1] = Zlen;
            stepOZ[2] = ZlenVn;
            stepOZ[3] = ZlenVn;

            stepOX = Alen / (xCnt - 1);
            stepOY = Blen / (yCnt - 1);

            double ox = 0,
                   oy = 0,
                   oz = 0;

            int kk = 0;
            int st = 0;

            for (int k = 0; k < 4; k++) // цикл по OZ
            {
                oy = 0;
                for (int j = 0; j < yCnt; j++) //цикл по OY
                {
                    ox = 0;
                    for (int i = 0; i < xCnt; i++) //цикл по OX
                    {
                        st = 0; // статус узла
                        if (j == 0 || j == (yCnt - 1) || i == 0 || i == (xCnt - 1))
                            st = 1;

                        nodes[kk] = new Node(ox, oy, oz, st);
                        kk++;

                        ox += stepOX;
                    }
                    oy += stepOY;
                }
                oz += stepOZ[k];
            }

            // iy: cntSloi * iz + iy * xCnt + ix
            // r: cntSloi * iz + iy * xCnt + (ix+1)
            // p: cntSloi * iz + (iy+1) * xCnt + (ix+1)
            // n: cntSloi * iz + (iy+1) * xCnt + ix
            // ix: cntSloi * (iz+1) + iy * xCnt + ix
            // s: cntSloi * (iz+1) + iy * xCnt + (ix+1)
            // m: cntSloi * (iz+1) + (iy+1) * xCnt + (ix+1)
            // iz: cntSloi * (iz+1) + (iy+1) * xCnt + ix

            kk = 0;
            for (int iz = 0; iz < zCnt - 1; iz++)
                for (int iy = 0; iy < yCnt - 1; iy++)
                {
                    for (int ix = 0; ix < xCnt - 1; ix++)
                    {
                        int _i = cntSloi * iz + iy * xCnt + ix;
                        int _r = cntSloi * iz + iy * xCnt + (ix + 1);
                        int _p = cntSloi * iz + (iy + 1) * xCnt + (ix + 1);
                        int _n = cntSloi * iz + (iy + 1) * xCnt + ix;
                        int _j = cntSloi * (iz + 1) + iy * xCnt + ix;
                        int _s = cntSloi * (iz + 1) + iy * xCnt + (ix + 1);
                        int _m = cntSloi * (iz + 1) + (iy + 1) * xCnt + (ix + 1);
                        int _k = cntSloi * (iz + 1) + (iy + 1) * xCnt + ix;

                        //knip
                        elements[kk] = new Element(_n, _k, _m, _j);
                        kk++;
                        //ijkm
                        elements[kk] = new Element(_m, _p, _n, _i);
                        kk++;
                        //kmpj
                        elements[kk] = new Element(_n, _i, _j, _m);
                        kk++;
                        //rsim
                        elements[kk] = new Element(_s, _r, _p, _i);
                        kk++;
                        // mpir
                        elements[kk] = new Element(_i, _j, _m, _s);
                        kk++;
                        //rjim
                        elements[kk] = new Element(_i, _p, _s, _m);
                        kk++;
                    }
                }
        }
Exemple #2
0
        private void getCyrkMesh()
        {
            double R = readDoubleFromTextBox(TB_A); //длина пластинки
            double Zlen = readDoubleFromTextBox(TB_H); //толщина пластинки
            double ZlenVn = readDoubleFromTextBox(TB_Hvn); //толщина внешних слоёв

            int coun = readIntFromTextBox(tb_x); //количество узлов первый слой
            int slo = readIntFromTextBox(tb_y); //количество слоёв
            int zCnt = 4;//readIntFromTextBox(tb_z); //количество узлов по OZ

            int[] countUzl = new int[slo];  //количество узлов на каждом ряде
            countUzl[0] = coun;
            for (int i = 1; i < slo; i++)
            {
                countUzl[i] = countUzl[i - 1] * 2;
            }

            int obCntUzelSl = 1; //общее количество узлов на каждом слое
            for (int i = 0; i < countUzl.Length; i++)
                obCntUzelSl += countUzl[i];

            obCountUzl = obCntUzelSl * zCnt; //общее количество узлов модели

            int[] cntElemRsl = new int[slo];

            cntElemRsl[0] = countUzl[0]; //общее количество элементов на ряде
            for (int i = 1; i < slo; i++)
            {
                cntElemRsl[i] = countUzl[i - 1] * 3;
            }

            int cntElemSloi = 0; //общее количество элементов на слое
            for (int i = 0; i < slo; i++)
            {
                cntElemSloi += cntElemRsl[i];
            }
            SLOI = cntElemSloi * 3;
            obCountElem = cntElemSloi * (zCnt - 1) * 3; //общее количество элементов модели

            nodes = new Node[obCountUzl]; //массив всех узлов
            elements = new Element[obCountElem]; //массив конечных элементов

            int kk = 0; //счётчик узлов

            //stepOZ; //щаг по OZ
            double[] stepOZ = new double[4];
            //шаги
            stepOZ[0] = ZlenVn;
            stepOZ[1] = Zlen;
            stepOZ[2] = ZlenVn;
            stepOZ[3] = ZlenVn;

            double oz = 0;
            int st = 0;
            double stepR = R / slo;

            for (int Ksl = 0; Ksl < zCnt; Ksl++)
            {
                nodes[kk] = new Node(0, 0, oz, 0);
                kk++;

                double curR = stepR;
                for (int j = 0; j < slo; j++)
                {
                    double fi = (2 * Math.PI) / (double)countUzl[j];

                    int k = 0;
                    for (double i = 0; k < countUzl[j]; i += fi)
                    {
                        st = 0; // статус узла
                        if (j == slo - 1)
                            st = 1;

                        nodes[kk] = new Node(curR * Math.Cos(i), curR * Math.Sin(i), oz, st);

                        kk++;
                        k++;

                    }

                    curR += stepR;
                }

                oz += stepOZ[Ksl];
            }

            int[][] starts = new int[zCnt][];

            for (int i = 0; i < zCnt; i++)
                starts[i] = new int[slo];

            starts[0][0] = 1;

            for (int i = 1; i < slo; i++)
                starts[0][i] = starts[0][i - 1] + countUzl[i - 1];

            for (int i = 1; i < zCnt; i++)
            {
                starts[i][0] = obCntUzelSl * i + 1;
                for (int j = 1; j < slo; j++)
                    starts[i][j] = starts[i][j - 1] + countUzl[j - 1];
            }

            /*формирование первого ряда элементов (внутреннего)*/
            kk = 0;

            for (int j = 0; j < zCnt - 1; j++)
            {
                /*внутренний слой*/
                for (int i = 0; i < cntElemRsl[0] - 1; i++)
                {
                    int _i = starts[j][0] - 1;
                    int _j = starts[j][0] + i;
                    int _k = starts[j][0] + i + 1;

                    int _p = starts[j + 1][0] - 1;
                    int _n = starts[j + 1][0] + i;
                    int _m = starts[j + 1][0] + i + 1;

                    //1: pijk
                    elements[kk] = new Element(_p, _i, _j, _k);
                    kk++;
                    //2: jnpm
                    elements[kk] = new Element(_k, _m, _n, _p);
                    kk++;
                    //3: kmnp
                    elements[kk] = new Element(_j, _n, _k, _p);
                    kk++;
                }
                //1: pijk
                elements[kk] = new Element(starts[j + 1][0] - 1, starts[j][0] - 1, starts[j][0] + (cntElemRsl[0] - 1), starts[j][0]);
                kk++;
                //2: jnpm
                elements[kk] = new Element(starts[j][0], starts[j + 1][0], starts[j + 1][0] + (cntElemRsl[0] - 1), starts[j + 1][0] - 1);
                kk++;
                //3: kmnp
                elements[kk] = new Element(starts[j][0] + (cntElemRsl[0] - 1), starts[j + 1][0] + (cntElemRsl[0] - 1), starts[j][0], starts[j + 1][0] - 1);
                kk++;

                /*остальные слои*/
                for (int k = 0; k < slo - 1; k++)
                {
                    for (int i = 0; i < countUzl[k] - 1; i++)
                    {
                        int _i = starts[j][k] + i;
                        int _j = starts[j][k + 1] + i * 2;
                        int _k = starts[j][k + 1] + i * 2 + 1;
                        int _a = starts[j][k + 1] + i * 2 + 2;
                        int _b = starts[j][k] + i + 1;

                        int _p = starts[j + 1][k] + i;
                        int _n = starts[j + 1][k + 1] + i * 2;
                        int _m = starts[j + 1][k + 1] + i * 2 + 1;
                        int _q = starts[j + 1][k + 1] + i * 2 + 2;
                        int _h = starts[j + 1][k] + i + 1;

                        //Призма 1
                        elements[kk] = new Element(_p, _i, _j, _k);
                        kk++;
                        elements[kk] = new Element(_p, _n, _k, _j);
                        kk++;
                        elements[kk] = new Element(_p, _n, _m, _k);
                        kk++;
                        //Призма 2
                        elements[kk] = new Element(_p, _i, _k, _b);
                        kk++;
                        elements[kk] = new Element(_p, _h, _b, _k);
                        kk++;
                        elements[kk] = new Element(_p, _h, _k, _m);
                        kk++;
                        //Призма 3
                        elements[kk] = new Element(_h, _b, _k, _a);
                        kk++;
                        elements[kk] = new Element(_h, _m, _a, _k);
                        kk++;
                        elements[kk] = new Element(_h, _m, _q, _a);
                        kk++;

                    }
                    //*Последние призмы*//

                    int l_i = starts[j][k] + (countUzl[k] - 1);
                    int l_j = starts[j][k + 1] + (countUzl[k] - 1) * 2;
                    int l_k = starts[j][k + 1] + (countUzl[k] - 1) * 2 + 1;
                    int l_a = starts[j][k + 1];
                    int l_b = starts[j][k];

                    int l_p = starts[j + 1][k] + (countUzl[k] - 1);
                    int l_n = starts[j + 1][k + 1] + (countUzl[k] - 1) * 2;
                    int l_m = starts[j + 1][k + 1] + (countUzl[k] - 1) * 2 + 1;
                    int l_q = starts[j + 1][k + 1];
                    int l_h = starts[j + 1][k];

                    //Призма 1
                    elements[kk] = new Element(l_p, l_i, l_j, l_k);
                    kk++;
                    elements[kk] = new Element(l_p, l_n, l_k, l_j);
                    kk++;
                    elements[kk] = new Element(l_p, l_n, l_m, l_k);
                    kk++;
                    //Призма 2
                    elements[kk] = new Element(l_p, l_i, l_k, l_b);
                    kk++;
                    elements[kk] = new Element(l_p, l_h, l_b, l_k);
                    kk++;
                    elements[kk] = new Element(l_p, l_h, l_k, l_m);
                    kk++;
                    //Призма 3
                    elements[kk] = new Element(l_h, l_b, l_k, l_a);
                    kk++;
                    elements[kk] = new Element(l_h, l_m, l_a, l_k);
                    kk++;
                    elements[kk] = new Element(l_h, l_m, l_q, l_a);
                    kk++;
                }

            }
        }