示例#1
0
        //nodes count ox
        /// <summary>
        /// Разбиение пластинки на трехмерные элементы
        /// </summary>
        /// <param name="box">Форма пластинки</param>
        /// <param name="NcntOX">Количество узлов по иси X</param>
        /// <param name="NcntOY">Количество узлов по иси Y</param>
        /// <param name="NcntOZ">Количество узлов по иси Z</param>
        public void MeshPlate(Box box, int nCntOX, int nCntOY, int nCntOZ)
        {
            /*формирование сетки для квадратной пластинки*/
            //количество узлов на слое
            int cntSloi = nCntOX * nCntOY;
            //общее количество узлов модели
            int obCountUzl = cntSloi * nCntOZ;
            //количество КВАДРАТНЫХ элементов на слое
            int cntElemSloi = (nCntOX - 1) * (nCntOY - 1);
            //общее количество ТЕТРАИДАЛЬНЫХ элементов модели
            int countElem = cntElemSloi * (nCntOZ - 1) * 6;

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

            bondary = new Bondary();

            double stepOX; //шаг по OX
            double stepOY; //шаг по OY
            double stepOZ; //шаг по ОZ

            stepOX = box.lenght / (nCntOX - 1);
            stepOY = box.width / (nCntOY - 1);
            stepOZ = box.height / (nCntOZ - 1);

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

            int kk = 0;
            // int st = 0;

            for (int k = 0; k < nCntOZ; k++) // цикл по OZ
            {
                oy = 0;
                for (int j = 0; j < nCntOY; j++) //цикл по OY
                {
                    ox = 0;
                    for (int i = 0; i < nCntOX; i++) //цикл по OX
                    {
                        //st = 0; // статус узла
                        if (j == 0 || j == (nCntOY - 1) || i == 0 || i == (nCntOX - 1))
                            bondary.around.Add(kk);

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

                        ox += stepOX;
                    }
                    oy += stepOY;
                }
                oz += stepOZ;
            }

            // i: cntSloi * iz     + iy     * nCntOX + ix
            // r: cntSloi * iz     + iy     * nCntOX + (ix+1)
            // p: cntSloi * iz     + (iy+1) * nCntOX + (ix+1)
            // n: cntSloi * iz     + (iy+1) * nCntOX + ix
            // j: cntSloi * (iz+1) + iy     * nCntOX + ix
            // s: cntSloi * (iz+1) + iy     * nCntOX + (ix+1)
            // m: cntSloi * (iz+1) + (iy+1) * nCntOX + (ix+1)
            // k: cntSloi * (iz+1) + (iy+1) * nCntOX + ix

            kk = 0;
            for (int iz = 0; iz < nCntOZ - 1; iz++)
                for (int iy = 0; iy < nCntOY - 1; iy++)
                {
                    for (int ix = 0; ix < nCntOX - 1; ix++)
                    {
                        int i = cntSloi * iz + iy * nCntOX + ix;
                        int r = cntSloi * iz + iy * nCntOX + (ix + 1);
                        int p = cntSloi * iz + (iy + 1) * nCntOX + (ix + 1);
                        int n = cntSloi * iz + (iy + 1) * nCntOX + ix;
                        int j = cntSloi * (iz + 1) + iy * nCntOX + ix;
                        int s = cntSloi * (iz + 1) + iy * nCntOX + (ix + 1);
                        int m = cntSloi * (iz + 1) + (iy + 1) * nCntOX + (ix + 1);
                        int k = cntSloi * (iz + 1) + (iy + 1) * nCntOX + ix;

                        //knip
                        elements[kk] = new ElementType.Tetra4N(n, k, m, j);
                        kk++;
                        //ijkm
                        elements[kk] = new ElementType.Tetra4N(m, p, n, i);
                        kk++;
                        //kmpj
                        elements[kk] = new ElementType.Tetra4N(n, i, j, m);
                        kk++;
                        //rsim
                        elements[kk] = new ElementType.Tetra4N(s, r, p, i);
                        kk++;
                        // mpir
                        elements[kk] = new ElementType.Tetra4N(i, j, m, s);
                        kk++;
                        //rjim
                        elements[kk] = new ElementType.Tetra4N(i, p, s, m);
                        kk++;
                    }
                }
        }
示例#2
0
        public void MeshRectangle(Shaft shaft, int NcntOX, int NcntOY)
        {
            //Количество узлов сетки
            int nodeCount = NcntOX * NcntOY;
            //Генерирование массива узлов
            nodes = new Node[nodeCount];
            bondary = new Bondary();

            double stepOX = shaft._lenght / ((double)NcntOX - 1);
            double stepOY = shaft._width / ((double)NcntOY - 1);

            double baseX = 0;
            double baseY = 0;

            int k = 0;
            for (int i = 0; i < NcntOY; i++)
                for (int j = 0; j < NcntOX; j++)
                {
                    nodes[k] = new Node(baseX + j * stepOX, baseY + i * stepOY);

                    if (j == 0)
                    {
                        bondary.left.Add(k);
                    }
                    else if (j == (NcntOX - 1))
                    {
                        bondary.right.Add(k);
                    }

                    if (i == 0)
                    {
                        bondary.bottom.Add(k);
                    }
                    else if (i == (NcntOY - 1))
                    {
                        bondary.top.Add(k);
                    }

                    k++;
                }

            //Формирование сетки
            //количество квадаратов
            int ElementCount = (NcntOX - 1) * (NcntOY - 1);
            elements = new ElementType.Trigle2D[ElementCount * 2];
            k = 0;

            for (int i = 0; i < NcntOY - 1; i++)
                for (int j = 0; j < NcntOX - 1; j++)
                {
                    elements[k] = new ElementType.Trigle2D(j + i * NcntOX,
                                                           j + i * NcntOX + 1,
                                                          (i + 1) * NcntOX + j);
                    k++;
                    elements[k] = new ElementType.Trigle2D((i + 1) * NcntOX + j + 1,
                                                           (i + 1) * NcntOX + j,
                                                           i * NcntOX + 1 + j);
                    k++;
                }
        }