Example #1
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++;
                }
        }
Example #2
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++;
                    }
                }
        }
Example #3
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) //nodes count ox
        //{
        //    /*формирование сетки для квадратной пластинки*/
        //    //количество узлов на слое
        //    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);
        //                if (i == 0)
        //                    bondary.left.Add(kk);
        //                if (i == nCntOX-1)
        //                    bondary.right.Add(kk);
        //                if (j == 0)
        //                    bondary.back.Add(kk);
        //                if (j == nCntOY - 1)
        //                    bondary.front.Add(kk);
        //                if(k == 0 )
        //                    bondary.bottom.Add(kk);
        //                if (k == nCntOZ -1)
        //                    bondary.top.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++;
        //            }
        //        }
        //}
        /// <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, double heightOwner)
        {
            /*формирование сетки для квадратной пластинки*/
            //количество узлов на слое
            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 = new double[6]; //шаг по ОZ

            int[] mater = new int[6];
            mater[0] = 0;
            mater[1] = 1;
            mater[2] = 1;
            mater[3] = 1;
            mater[4] = 0;
            mater[5] = 0;

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

            double dtSrZ = (box.height - 2.0 * heightOwner)/3.0;
            stepOZ[0] = heightOwner;
            stepOZ[1] = dtSrZ;
            stepOZ[2] = dtSrZ;
            stepOZ[3] = dtSrZ;
            stepOZ[4] = heightOwner;

            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);
                        if (i == 0)
                            bondary.left.Add(kk);
                        if (i == nCntOX - 1)
                            bondary.right.Add(kk);
                        if (j == 0)
                            bondary.back.Add(kk);
                        if (j == nCntOY - 1)
                            bondary.front.Add(kk);
                        if (k == 0)
                            bondary.bottom.Add(kk);
                        if (k == nCntOZ - 1)
                            bondary.top.Add(kk);

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

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

            // 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,mater[iz]);
                        kk++;
                        //ijkm
                        elements[kk] = new ElementType.Tetra4N(m, p, n, i, mater[iz]);
                        kk++;
                        //kmpj
                        elements[kk] = new ElementType.Tetra4N(n, i, j, m, mater[iz]);
                        kk++;
                        //rsim
                        elements[kk] = new ElementType.Tetra4N(s, r, p, i, mater[iz]);
                        kk++;
                        // mpir
                        elements[kk] = new ElementType.Tetra4N(i, j, m, s, mater[iz]);
                        kk++;
                        //rjim
                        elements[kk] = new ElementType.Tetra4N(i, p, s, m, mater[iz]);
                        kk++;
                    }
                }
        }