예제 #1
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Node load
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Member transverse load
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Primary End Forces in Local Coordinate System of Member
        // Member default - no transverse load at member
        public void GetEndLoad(CE_1D Element)
        {
            for (int i = 0; i < 6; i++)
            {
                Element.m_VElemPEF_LCS_StNode.FVectorItems[i] = 0f;
                Element.m_VElemPEF_LCS_EnNode.FVectorItems[i] = 0f;
            }

            // Set Primary End Forces of Elemnent in Global Coordinate system
            SetGetPEF_GCS(Element);

            // Update Element Primary End Forces Vector (1x12) in LCS
            UpdateElemPEF_LCS_Vector(Element);
            // Update Element Primary End Forces Vector (1x12) in GCS
            UpdateElemPEF_GCS_Vector(Element);
        }
예제 #2
0
파일: CFEM_CALC.cs 프로젝트: 777ondro/sw-en
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // TEMPORARY EXAMPLE DATA
        // Consructor - old
        public CFEM_CALC()
        {
            // Geometry
            float fGeom_a = 4f,
                  fGeom_b = 5f,
                  fGeom_c = 3.5f;     // Unit [m]

            // Material
            CMaterial m_Mat = new CMaterial();

            // Cross-section
            CCrSc m_CrSc = new CCrSc_3_00(0, 8, 300, 125, 16.2f, 10.8f, 10.8f, 6.5f, 241.6f); // I 300 section // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            m_CrSc.FI_t = 5.69e-07f;
            m_CrSc.FI_y = 9.79e-05f;
            m_CrSc.FI_z = 4.49e-06f;
            m_CrSc.FA_g = 6.90e-03f;
            m_CrSc.FA_vy = 4.01e-03f;
            m_CrSc.FA_vz = 2.89e-03f;

            // Define Nodes Properties

            for (int i = 0; i < iNNoTot; i++)
            {
                // Create auxiliary Node object
                CFemNode CNode_i = new CFemNode(iNodeDOFNo);

                // Fill array object item with auxliary Node
                m_NodeArray[i] = CNode_i;
            }

            // Node 1
            m_NodeArray[0].ID = 1;
            m_NodeArray[0].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUX] = fGeom_a;
            m_NodeArray[0].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUY] = 0f;
            m_NodeArray[0].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUZ] = 0f;

            // Node 2
            m_NodeArray[1].ID = 2;
            m_NodeArray[1].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUX] = 0f;
            m_NodeArray[1].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUY] = 0f;
            m_NodeArray[1].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUZ] = 0f;

            // Node 3
            m_NodeArray[2].ID = 5;
            m_NodeArray[2].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUX] = fGeom_a;
            m_NodeArray[2].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUY] = 0f;
            m_NodeArray[2].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUZ] = -fGeom_c;

            // Node 4
            m_NodeArray[3].ID = 3;
            m_NodeArray[3].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUX] = fGeom_a;
            m_NodeArray[3].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUY] = -fGeom_b;
            m_NodeArray[3].m_fVNodeCoordinates.FVectorItems[(int) e3D_DOF.eUZ] = 0f;

            // Set Nodal Supports (for restraint set 0f)
            // Node 1

            // Node 2
            m_NodeArray[1].m_VDisp.FVectorItems[0] = 0f;
            m_NodeArray[1].m_VDisp.FVectorItems[1] = 0f;
            m_NodeArray[1].m_VDisp.FVectorItems[2] = 0f;
            m_NodeArray[1].m_VDisp.FVectorItems[3] = 0f;
            m_NodeArray[1].m_VDisp.FVectorItems[4] = 0f;
            m_NodeArray[1].m_VDisp.FVectorItems[5] = 0f;

            // Node 3
            m_NodeArray[2].m_VDisp.FVectorItems[0] = 0f;
            m_NodeArray[2].m_VDisp.FVectorItems[1] = 0f;
            m_NodeArray[2].m_VDisp.FVectorItems[2] = 0f;
            m_NodeArray[2].m_VDisp.FVectorItems[3] = 0f;
            m_NodeArray[2].m_VDisp.FVectorItems[4] = 0f;
            m_NodeArray[2].m_VDisp.FVectorItems[5] = 0f;

            // Node 4
            m_NodeArray[3].m_VDisp.FVectorItems[0] = 0f;
            m_NodeArray[3].m_VDisp.FVectorItems[1] = 0f;
            m_NodeArray[3].m_VDisp.FVectorItems[2] = 0f;
            m_NodeArray[3].m_VDisp.FVectorItems[3] = 0f;
            m_NodeArray[3].m_VDisp.FVectorItems[4] = 0f;
            m_NodeArray[3].m_VDisp.FVectorItems[5] = 0f;

            // Set Global Code Numbers

            int m_iCodeNo = 0; // Number of unrestrained degrees of freedom - finally gives size of structure global matrix

            foreach (CFemNode i_CNode in m_NodeArray) // Each Node
            {
                for (int i = 0; i < iNodeDOFNo; i++)     // Each DOF
                {
                    if (i_CNode.m_VDisp.FVectorItems[i] != 0)  // Perform for not restrained DOF
                    {
                        i_CNode.m_ArrNCodeNo[i] = m_iCodeNo; // Set global code number of degree of freedom (DOF)

                        m_iCodeNo++;
                    }
                }
            }

            // Fill members of structure global vector of displacement
            // Now we know number of not restrained DOF, so we can allocate array size
            m_fDisp_Vector_CN = new int[m_iCodeNo,3]; // 1st - global DOF code number, 2nd - Node index, 3rd - local code number of DOF in NODE

            FillGlobalDisplCodeNoOld();

            ////////////////////////////////////////////////////////////////////////////////////
            // Set Nodal Loads (acting directly in nodes)

            ////////////////////////////////////////////////////////////////////////////////////
            // !!!!!! No kind of these loads actually

            ///////////////////////////////////////////////////////////////////////////////////////
            // Define FEM 1D elements
            ///////////////////////////////////////////////////////////////////////////////////////

            for (int i = 0; i < iElemNoTot; i++)
            {
                // Create auxiliary Element object
                CE_1D CElement_i = new CE_1D();
                // Fill array object item
                m_ELemArray[i] = CElement_i;

                // Create auxiliary Element Load Object
                CLoad CLoad_i = new CLoad();
                // Fill array object item
                m_ELoadArray[i] = CLoad_i;
            }

            // Member 1 [0] Nodes 1 - 2 ([0] [1])
            m_ELemArray[0].NodeStart = m_NodeArray[0];
            m_ELemArray[0].NodeEnd = m_NodeArray[1];
            // Element  Type
            m_ELemArray[0].m_eSuppType3D = EElemSuppType3D.e3DEl_000000_000000;
            // Element Material
            m_ELemArray[0].m_Mat = m_Mat;
            // Element Corss-section
            m_ELemArray[0].m_CrSc = m_CrSc;
            // Fill Basic Element Data
            m_ELemArray[0].FillBasic2();
            // Load of Element only due to Element Transversal Forces
            m_ELoadArray[0].GetEndLoad_g(m_ELemArray[0], m_fq);
            // Output
            // kij_0 - local stiffeness matrix       6 x  6
            m_ELemArray[0].m_fkLocMatr.Print2DMatrixFormated();
            // A  Tranformation Rotation Matrixes    6 x  6
            m_ELemArray[0].m_fATRMatr3D.Print2DMatrixFormated();
            // B  Transfer Matrixes                  6 x  6
            m_ELemArray[0].m_fBTTMatr3D.Print2DMatrixFormated();
            // Kij - global matrix of member        12 x 12
            m_ELemArray[0].m_fKGlobM.Print2DMatrixFormated();
            // Element Load Vector                   2 x  6
            m_ELemArray[0].m_ArrElemPEF_LCS.Print2DMatrixFormated();

            #region MATRIX TEST
            /////////////////////////////////////////////////////////////////////////////////////////////////////
            // TEST
            /*
            float[,] farrk11 = new float[6, 6];
            float[,] farrk12 = new float[6, 6];
            float[,] farrk21 = new float[6, 6];
            float[,] farrk22 = new float[6, 6];

            // Fill array
            for (int i = 0; i < 6; i++)
            {
               for (int j = 0; j < 6; j++)
                {
                    farrk11[i, j] = ((i+1)*10)+1 + j;
                }
            }

            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    farrk12[i, j] = ((i + 1) * 10) + 1 + j;
                }
            }

            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    farrk21[i, j] = ((i + 1) * 10) + 1 + j;
                }
            }

            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    farrk22[i, j] = ((i + 1) * 10) + 1 + j;
                }
            }

            float[,][,] farrK = new float[2, 2][,]
                    {{farrk11, farrk12},
                    {farrk21, farrk22}};

            Console.WriteLine(m_ELemArray[0].CM.Print2DMatrix(farrK, 2, 6));
            */
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
            #endregion

            // Member 2 [1] Nodes 1 - 3 ([0] [2])
            m_ELemArray[1].NodeStart = m_NodeArray[0];
            m_ELemArray[1].NodeEnd = m_NodeArray[2];
            // Element  Type
            m_ELemArray[1].m_eSuppType3D = EElemSuppType3D.e3DEl_000000_000000;
            // Element Material
            m_ELemArray[1].m_Mat = m_Mat;
            // Element Corss-section
            m_ELemArray[1].m_CrSc = m_CrSc;
            // Fill Basic Element Data
            m_ELemArray[1].FillBasic2();
            // Load of Element only due to Element Transversal Forces
            m_ELoadArray[1].GetEndLoad_F(m_ELemArray[1], 0f, 0f, m_fF);
            // Output
            // kij_0 - local stiffeness matrix       6 x  6
               m_ELemArray[1].m_fkLocMatr.Print2DMatrixFormated();
            // A  Tranformation Rotation Matrixes    6 x  6
            m_ELemArray[1].m_fATRMatr3D.Print2DMatrixFormated();
            // B  Transfer Matrixes                  6 x  6
            m_ELemArray[1].m_fBTTMatr3D.Print2DMatrixFormated();
            // Kij - global matrix of member        12 x 12
            m_ELemArray[1].m_fKGlobM.Print2DMatrixFormated();
            // Element Load Vector                   2 x  6
            m_ELemArray[1].m_ArrElemPEF_LCS.Print2DMatrixFormated();

            // Member 3 [2] Nodes 1 - 4 ([0] [3])
            m_ELemArray[2].NodeStart = m_NodeArray[0];
            m_ELemArray[2].NodeEnd = m_NodeArray[3];
            // Element  Type
            m_ELemArray[2].m_eSuppType3D = EElemSuppType3D.e3DEl_000000_000___;
            // Element Material
            m_ELemArray[2].m_Mat = m_Mat;
            // Element Corss-section
            m_ELemArray[2].m_CrSc = m_CrSc;
            // Fill Basic Element Data
            m_ELemArray[2].FillBasic2();
            // Load of Element only due to Element Transversal Forces
            m_ELoadArray[2].GetEndLoad_M(m_ELemArray[2], m_fM, 0f, 0f);
            // Output
            // kij_0 - local stiffeness matrix       6 x  6
            m_ELemArray[2].m_fkLocMatr.Print2DMatrixFormated();
            // A  Tranformation Rotation Matrixes    6 x  6
            m_ELemArray[2].m_fATRMatr3D.Print2DMatrixFormated();
            // B  Transfer Matrixes                  6 x  6
            m_ELemArray[2].m_fBTTMatr3D.Print2DMatrixFormated();
            // Kij - global matrix of member        12 x 12
            m_ELemArray[2].m_fKGlobM.Print2DMatrixFormated();
            // Element Load Vector                   2 x  6
            m_ELemArray[2].m_ArrElemPEF_LCS.Print2DMatrixFormated();

            /*
            // Nodal loads (sum nodal loads and nodal loads due to element loads)
            m_NodeArray[2].m_sLoad.s_fFZ += -55000; // Add local nodal load to element ends loads due to intermediate load
            */

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Set Global Code Number of Nodes / Nastavit globalne kodove cisla uzlov
            // Save indexes of nodes and DOF which are free and represent vector of uknown variables in solution
            // Save it as array of arrays n x 2 (1st value is index - node index (0 - n-1) , 2nd value is DOF index (0-5)
            // n - total number of nodes in model
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            SetNodesGlobCodeNoOld(); // Nastavi DOF v uzlov globalne kodove cisla ???

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Right side of Equation System
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            // Global Stiffeness Matrix of Structure - Allocate Memory (Matrix Size)
            m_M_K_Structure = new CMatrix(m_iCodeNo);

            // Fill Global Stiffeness Matrix
            FillGlobalMatrixOld();

            // Global Stiffeness Matrix    m_iCodeNo x  m_iCodeNo
            m_M_K_Structure.Print2DMatrix();

            // Auxialiary temporary transformation from 2D to 1D array / from float do double
            // Pomocne prevody medzi jednorozmernym, dvojroymernym polom a triedom Matrix,
            // bude nutne zladit a format v akom budeme pracovat s datami a potom zmazat

            CArray objArray = new CArray();
            // Convert Size
            float[] m_M_K_fTemp1D = objArray.ArrTranf2Dto1D(m_M_K_Structure.m_fArrMembers);
            // Convert Type
            double[] m_M_K_dTemp1D = objArray.ArrConverFloatToDouble1D(m_M_K_fTemp1D);

            MatrixF64 objMatrix = new MatrixF64(6, 6, m_M_K_dTemp1D);
            // Print Created Matrix of MatrixF64 Class
            objMatrix.WriteLine();
            // Get Inverse Global Stiffeness Matrix
            MatrixF64 objMatrixInv =  objMatrix.Inverse();
            // Print Inverse Matrix
            objMatrixInv.WriteLine();
            // Convert Type
            float[] m_M_K_Inv_fTemp1D = objArray.ArrConverMatrixF64ToFloat1D(objMatrixInv);
            // Inverse Global Stiffeness Matrix of Structure - Allocate Memory (Matrix Size)
            CMatrix m_M_K_Structure_Inv = new CMatrix(m_iCodeNo);
            m_M_K_Structure_Inv.m_fArrMembers = objArray.ArrTranf1Dto2D(m_M_K_Inv_fTemp1D);

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Left side of Equation System
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            // Global Load Vector - Allocate Memory (Vector Size)
            m_V_Load = new CVector(m_iCodeNo);

            // Fill Global Load Vector
            FillGlobalLoadVectorOld();

            // Display Global Load Vector
            m_V_Load.Print1DVector();

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Solution - calculation of unknown displacement of nodes in GCS - system of linear equations
            // Start Solver
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            // Global Displacement Vector - Allocate Memory (Vector Size)
            m_V_Displ = new CVector(m_iCodeNo);

            // Fill Global Displacement Vector
            m_V_Displ = VectorF.fMultiplyMatrVectr(m_M_K_Structure_Inv, m_V_Load);

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // End Solver
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            // Display Global Displacemnt Vector - solution result
            //Console.ForegroundColor = ConsoleColor.Cyan;
            m_V_Displ.Print1DVector();
            //Console.ForegroundColor = ConsoleColor.Green;
            //Console.BackgroundColor = ConsoleColor.White;

            // Set displacements and rotations of DOF in GCS to appropriate node DOF acc. to global code numbers
            for (int i = 0; i < m_iCodeNo; i++)
            {
                // Check if DOF is default (free - ) or has some initial value (settlement; soil consolidation etc.)
                // See Fill_NDisp_InitStr() for default values - float.PositiveInfinity
                if (m_NodeArray[m_fDisp_Vector_CN[i, 1]].m_VDisp.FVectorItems[m_fDisp_Vector_CN[i, 2]] == float.PositiveInfinity)
                    m_NodeArray[m_fDisp_Vector_CN[i, 1]].m_VDisp.FVectorItems[m_fDisp_Vector_CN[i, 2]] = m_V_Displ.FVectorItems[i]; // set calculated
                else // some real initial value exists
                    m_NodeArray[m_fDisp_Vector_CN[i, 1]].m_VDisp.FVectorItems[m_fDisp_Vector_CN[i, 2]] += m_V_Displ.FVectorItems[i]; // add calculated (to sum)
            }

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Get final end forces at element in global coordinate system GCS
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                for (int i = 0; i < iElemNoTot; i++)
                {
                    m_ELemArray[i].GetArrElemEF_GCS_StNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeStart.ID + "; " + "Start Node End Forces in GCS");
                    m_ELemArray[i].m_VElemEF_GCS_StNode.Print1DVector();
                    m_ELemArray[i].GetArrElemEF_GCS_EnNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeEnd.ID + "; " + "End Node End Forces in GCS");
                    m_ELemArray[i].m_VElemEF_GCS_EnNode.Print1DVector();
                    m_ELemArray[i].GetArrElemEF_LCS_StNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeStart.ID + "; " + "Start Node End Forces in LCS");
                    m_ELemArray[i].m_VElemEF_LCS_StNode.Print1DVector();
                    m_ELemArray[i].GetArrElemEF_LCS_EnNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeEnd.ID + "; " + "End Node End Forces in LCS");
                    m_ELemArray[i].m_VElemEF_LCS_EnNode.Print1DVector();
                    m_ELemArray[i].GetArrElemIF_LCS_StNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeStart.ID + "; " + "Start Node Internal Forces in LCS");
                    m_ELemArray[i].m_VElemIF_LCS_StNode.Print1DVector();
                    m_ELemArray[i].GetArrElemIF_LCS_EnNode();
                    Console.WriteLine("Element Index No.: " + i + "; " + "Node No.: " + m_ELemArray[i].NodeEnd.ID + "; " + "End Node Internal Forces in LCS");
                    m_ELemArray[i].m_VElemIF_LCS_EnNode.Print1DVector();
                }
        }
예제 #3
0
        //----------------------------------------------------------------------------
        //----------------------------------------------------------------------------
        //----------------------------------------------------------------------------
        public CMLoadPart(CModel TopoModel,
            CE_1D[] arrFemMembers,
            int iMLoadIndex,
            int kMemberIndex,
            out float fTemp_A_UXRX,
            out float fTemp_Ma_UXRX,
            out float fTemp_A_UYRZ,
            out float fTemp_Ma_UYRZ,
            out float fTemp_A_UZRY,
            out float fTemp_Ma_UZRY,
            out float fTemp_B_UXRX,
            out float fTemp_Mb_UXRX,
            out float fTemp_B_UYRZ,
            out float fTemp_Mb_UYRZ,
            out float fTemp_B_UZRY,
            out float fTemp_Mb_UZRY
            )
        {
            // Default
            fTemp_A_UXRX = 0.0f;
            fTemp_B_UXRX = 0.0f;
            fTemp_A_UYRZ = 0.0f;
            fTemp_B_UYRZ = 0.0f;
            fTemp_A_UZRY = 0.0f;
            fTemp_B_UZRY = 0.0f;
            fTemp_Ma_UXRX = 0.0f;
            fTemp_Mb_UXRX = 0.0f;
            fTemp_Ma_UYRZ = 0.0f;
            fTemp_Mb_UYRZ = 0.0f;
            fTemp_Ma_UZRY = 0.0f;
            fTemp_Mb_UZRY = 0.0f;

            if (TopoModel.m_arrMLoads[iMLoadIndex].IMemberCollection.Contains(TopoModel.m_arrMembers[kMemberIndex].ID)) // If member ID is same as collection item
            {
                // Fill external forces temp values

                switch (TopoModel.m_arrMLoads[iMLoadIndex].EDirPPC) // Load direction in principal coordinate system XX / YU / ZV
                {

                    // 0 - Displacement in x-axis and rotation about x-axis in PCS
                    // 1 - Displacement in y-axis and rotation about z-axis in PCS
                    // 2 - Displacement in z-axis and rotation about y-axis in PCS

                    case EMLoadDirPCC1.eMLD_PCC_FXX_MXX: // Axial force or torsional moment
                        {
                            // DOF RX can be released at one end only - one side is always supported
                            switch (arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX])
                            {
                                // Type of supports is already defined  but I check it once more in body of function !!!

                                // XX - direction both sides supported displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_00:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_0_:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__00:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__0_:
                                    {
                                        // Type ObjLoadType = typeof(TopoModel.m_arrMLoads[i]);
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Axial Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_AXIAL_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_AXIAL_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_A_UXRX,
                                                        out fTemp_B_UXRX);
                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Torsional Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_TORS objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TORS(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_Ma_UXRX,
                                                        out fTemp_Mb_UXRX);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // XX - direction start supported, end free displacement
                                //case FEM_CALC_BASE.Enums.EElemSuppType.eEl_00__0:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00___:
                                    //case FEM_CALC_BASE.Enums.EElemSuppType.eEl_0____:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Axial Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_AXIAL_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_AXIAL_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_A_UXRX,
                                                        out fTemp_B_UXRX);
                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Torsional Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_TORS objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TORS(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_Ma_UXRX,
                                                        out fTemp_Mb_UXRX);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // XX - direction start free displacement, end supported
                                //case FEM_CALC_BASE.Enums.EElemSuppType.eEl__0_00:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl____00:
                                    //case FEM_CALC_BASE.Enums.EElemSuppType.eEl____0_:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Axial Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_AXIAL_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_AXIAL_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_A_UXRX,
                                                        out fTemp_B_UXRX);
                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Torsional Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_TORS objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TORS(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_Ma_UXRX,
                                                        out fTemp_Mb_UXRX);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // XX - direction start free displacement, end free displacement
                                //case FEM_CALC_BASE.Enums.EElemSuppType.eEl__0__0:
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl______:
                                default:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Axial Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_AXIAL_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_AXIAL_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_A_UXRX,
                                                        out fTemp_B_UXRX);
                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Torsional Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_TORS objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TORS(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUXRX],
                                                        out fTemp_Ma_UXRX,
                                                        out fTemp_Mb_UXRX);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                            }
                            break;
                        }
                    case EMLoadDirPCC1.eMLD_PCC_FYU_MZV: // Transversal load
                        {
                            switch (arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ])
                            {
                                // Type of supports is already defined  but I check it once more in body of function !!!

                                // UZRY - direction both sides supported displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_0_:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__0_:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start supported, end free displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00___:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start free displacement, end supported
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl____00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start free displacement, end free displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl______:
                                default:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUYRZ],
                                                        out fTemp_A_UYRZ,
                                                        out fTemp_B_UYRZ,
                                                        out fTemp_Ma_UYRZ,
                                                        out fTemp_Mb_UYRZ);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                            }
                            break;
                        }
                    case EMLoadDirPCC1.eMLD_PCC_FZV_MYU: // Transversal load
                        {
                            switch (arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY])
                            {
                                // Type of supports is already defined  but I check it once more in body of function !!!

                                // UZRY - direction both sides supported displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00_0_:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_0__0_:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start supported, end free displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl_00___:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start free displacement, end supported
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl____00:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                                // UZRY - direction start free displacement, end free displacement
                                case FEM_CALC_BASE.Enums.EElemSuppType2D.eEl______:
                                default:
                                    {
                                        switch (TopoModel.m_arrMLoads[iMLoadIndex].MLoadType)
                                        {
                                            case BaseClasses.EMLoadType.eMLT_F:  // Transverse Force
                                                {
                                                    FEM_CALC_BASE.CMLoadPart_TRANS_F objMLoadPart = new FEM_CALC_BASE.CMLoadPart_TRANS_F(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);

                                                    break;
                                                }
                                            case BaseClasses.EMLoadType.eMLT_M: // Bending Moment
                                                {

                                                    FEM_CALC_BASE.CMLoadPart_BEND objMLoadPart = new FEM_CALC_BASE.CMLoadPart_BEND(TopoModel.m_arrMLoads[iMLoadIndex],
                                                        (CE_1D_BASE)arrFemMembers[kMemberIndex],
                                                        arrFemMembers[kMemberIndex].m_eSuppType2D[(int)EM_PCS_DIR1.eUZRY],
                                                        out fTemp_A_UZRY,
                                                        out fTemp_B_UZRY,
                                                        out fTemp_Ma_UZRY,
                                                        out fTemp_Mb_UZRY);
                                                    break;
                                                }
                                            default:
                                                {

                                                    break;
                                                }
                                        }

                                        break;
                                    }
                            }
                            break;
                        }
                    default: // Exception
                        {
                            fTemp_A_UXRX = float.MaxValue;
                            fTemp_B_UXRX = float.MaxValue;
                            fTemp_A_UYRZ = float.MaxValue;
                            fTemp_B_UYRZ = float.MaxValue;
                            fTemp_A_UZRY = float.MaxValue;
                            fTemp_B_UZRY = float.MaxValue;
                            fTemp_Ma_UXRX = float.MaxValue;
                            fTemp_Mb_UXRX = float.MaxValue;
                            fTemp_Ma_UYRZ = float.MaxValue;
                            fTemp_Mb_UYRZ = float.MaxValue;
                            fTemp_Ma_UZRY = float.MaxValue;
                            fTemp_Mb_UZRY = float.MaxValue;

                            break;
                        }
                }
            }
        }
예제 #4
0
파일: CGenex.cs 프로젝트: 777ondro/sw-en
        public void GenerateMesh1D(CModel TopoModel)
        {
            // Generate FEM nodes
            // Nodes
            for (int i = 0; i < TopoModel.m_arrNodes.Length; i++)
            {
                // Create FEM node
                CFemNode TempNode = new CFemNode(TopoModel.m_arrNodes[i]);
                m_arrFemNodes[i] = TempNode;

                // Set FEM node DOF

                // Get nodal support
                // Search if node is in list of supported nodes for each nodal support
                for (int i2 = 0; i2 < TopoModel.m_arrNSupports.Length; i2++) // Check all nodal supports
                {
                    for (int j = 0; j < TopoModel.m_arrNSupports[i2].m_iNodeCollection.Length; j++) // Check list of nodes (Nodes IDs collection)
                    {
                        if (m_arrFemNodes[i].ID == TopoModel.m_arrNSupports[i2].m_iNodeCollection[j])
                        {
                            // DOF of nodes are free - zero rigidity of restraints  false as default
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eUX] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eUX]; // !!! 3D Environment enum
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eUY] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eUY]; // !!! 3D Environment enum
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eUZ] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eUZ]; // !!! 3D Environment enum
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eRX] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eRX]; // !!! 3D Environment enum
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eRY] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eRY]; // !!! 3D Environment enum
                            m_arrFemNodes[i].m_ArrNodeDOF[(int)e3D_DOF.eRZ] = TopoModel.m_arrNSupports[i2].m_bRestrain[(int)e3D_DOF.eRZ]; // !!! 3D Environment enum
                        }
                    }
                }
            }

            // Generate FEM members
            // Members
            for (int i = 0; i < TopoModel.m_arrMembers.Length; i++)
            {
                CE_1D TempMember = new CE_1D(TopoModel.m_arrMembers[i], m_arrFemNodes);
                m_arrFemMembers[i] = TempMember;

                // Set FEM Member DOF
                if (TopoModel.m_arrNReleases != null) // Some releases exist
                {
                    for (int j = 0; j < TopoModel.m_arrNReleases.Length; j++) // Check each release
                    {
                        for (int k = 0; k < TopoModel.m_arrNReleases[j].m_iMembCollection.Length; k++) //  Check each member in collection
                        {
                            if (TopoModel.m_arrNReleases[j].m_iMembCollection[k] == m_arrFemMembers[i].ID) // if release exists on member
                            {
                                if (TopoModel.m_arrMembers[i].CnRelease1 != null)
                                    m_arrFemMembers[i].CnRelease1 = TopoModel.m_arrMembers[i].CnRelease1;
                                if (TopoModel.m_arrMembers[i].CnRelease2 != null)
                                    m_arrFemMembers[i].CnRelease2 = TopoModel.m_arrMembers[i].CnRelease2;
                            }
                        }
                    }
                }
            }

            ////////////////////////////////////////////////////////////////////////////////////////////////
            // Additional data of nodes depending on generated members

            for (int i = 0; i < m_arrFemNodes.Length; i++)
            {
                m_arrFemNodes[i].m_iMemberCollection = new System.Collections.ArrayList(); // Allocate collection memory

                for (int j = 0; j < m_arrFemMembers.Length; j++)
                {
                    if (m_arrFemNodes[i].ID == m_arrFemMembers[j].NodeStart.ID || m_arrFemNodes[i].ID == m_arrFemMembers[j].NodeEnd.ID) // Is node ID same as member start or end node ID
                    {
                        m_arrFemNodes[i].m_iMemberCollection.Add(m_arrFemMembers[j].ID); // Add FEMmember ID to the FEM node list
                    }
                }
            }

            // Releases !!!! - copied from 2D solution, check implementation in 3D !!!

            //  If only two members are connected in one node and if release exists at that node, copy this release from one member to the another
            for (int i = 0; i < m_arrFemNodes.Length; i++)
            {
                if (m_arrFemNodes[i].m_iMemberCollection != null && m_arrFemNodes[i].m_iMemberCollection.Count == 2) // Node is connected to two members
                {
                    // We know member ID, so we can get index of members in list
                    int iMember1_index = -1;
                    int iMember2_index = -1;

                    for (int j = 0; j < m_arrFemMembers.Length; j++)
                    {
                        // 1st member index
                        if (iMember1_index < 0 && m_arrFemNodes[i].m_iMemberCollection.Contains(m_arrFemMembers[j].ID)) // if Member ID is in the list
                        {
                            iMember1_index = j; // Set 1st
                        }

                        if (iMember1_index > -1) // Index was defined, we can break cycle
                            break;
                    }

                    // 2nd member index
                    for (int k = iMember1_index + 1; k < m_arrFemMembers.Length; k++) // Search for second only in interval between first founded member and last member
                    {
                        if (iMember2_index < 0 && m_arrFemNodes[i].m_iMemberCollection.Contains(m_arrFemMembers[k].ID)) // if Member ID is in the list interval
                        {
                            iMember2_index = k;
                        }

                        if (iMember2_index > -1) // Index was defined, we can break cycle
                            break;
                    }

                    // If relases exist, they are neccesary to define DOF of both members, therefore copy release of one member to the another one
                    if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeStart.ID && m_arrFemMembers[iMember1_index].CnRelease1 != null)
                    {
                        if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeStart.ID && m_arrFemMembers[iMember2_index].CnRelease1 == null)
                            m_arrFemMembers[iMember2_index].CnRelease1.m_bRestrain = m_arrFemMembers[iMember1_index].CnRelease1.m_bRestrain;
                        else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeEnd.ID && m_arrFemMembers[iMember2_index].CnRelease2 == null)
                            m_arrFemMembers[iMember2_index].CnRelease2.m_bRestrain = m_arrFemMembers[iMember1_index].CnRelease1.m_bRestrain;
                    }
                    else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeEnd.ID && m_arrFemMembers[iMember1_index].CnRelease2 != null)
                    {
                        if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeStart.ID && m_arrFemMembers[iMember2_index].CnRelease1 == null)
                            m_arrFemMembers[iMember2_index].CnRelease1.m_bRestrain = m_arrFemMembers[iMember1_index].CnRelease2.m_bRestrain;
                        else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeEnd.ID && m_arrFemMembers[iMember2_index].CnRelease2 == null)
                            m_arrFemMembers[iMember2_index].CnRelease2.m_bRestrain = m_arrFemMembers[iMember1_index].CnRelease2.m_bRestrain;
                    }
                    else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeStart.ID && m_arrFemMembers[iMember2_index].CnRelease1 != null)
                    {
                        if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeStart.ID && m_arrFemMembers[iMember1_index].CnRelease1 == null)
                            m_arrFemMembers[iMember1_index].CnRelease1.m_bRestrain = m_arrFemMembers[iMember2_index].CnRelease1.m_bRestrain;
                        else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeEnd.ID && m_arrFemMembers[iMember1_index].CnRelease2 == null)
                            m_arrFemMembers[iMember1_index].CnRelease2.m_bRestrain = m_arrFemMembers[iMember2_index].CnRelease1.m_bRestrain;
                    }
                    else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember2_index].NodeEnd.ID && m_arrFemMembers[iMember2_index].CnRelease2 != null)
                    {
                        if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeStart.ID && m_arrFemMembers[iMember1_index].CnRelease1 == null)
                            m_arrFemMembers[iMember1_index].CnRelease1.m_bRestrain = m_arrFemMembers[iMember2_index].CnRelease2.m_bRestrain;
                        else if (m_arrFemNodes[i].ID == m_arrFemMembers[iMember1_index].NodeEnd.ID && m_arrFemMembers[iMember1_index].CnRelease2 == null)
                            m_arrFemMembers[iMember1_index].CnRelease2.m_bRestrain = m_arrFemMembers[iMember2_index].CnRelease2.m_bRestrain;
                    }
                }
            }

            // Additional data of members
            // Fill Members stifeness matrices
            for (int i = 0; i < m_arrFemMembers.Length; i++)
            {
                m_arrFemMembers[i].FillBasic3_StiffMatrices();
            }

            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // External Loads
            // Fill vectors

            // Nodal loads
            // Fill vector of external load for each node in list
            // Node could be included in all lists only once, more than one nodal load in one node is not allowed
            if (!object.ReferenceEquals(null, TopoModel.m_arrNLoads))
            {
                for (int i = 0; i < TopoModel.m_arrNLoads.Length; i++) // Each load
                {
                    if (TopoModel.m_arrNLoads[i].INodeCollection != null) // Check if some nodes are in list
                    {
                        for (int j = 0; j < TopoModel.m_arrNLoads[i].INodeCollection.Length; j++) // Each node in collection
                        {
                            // Set load vector values
                            for (int k = 0; k < m_arrFemNodes.Length; k++) // Neefektivne prechadzat zbytocne vsetky uzly kedze pozname konkretne ID zatazenych
                            {
                                if (TopoModel.m_arrNLoads[i].INodeCollection.Contains(TopoModel.m_arrNodes[k].ID)) // If node ID is same as collection item
                                {
                                    // Check object class
                                    if (TopoModel.m_arrNLoads[i] is BaseClasses.CNLoadAll)
                                    {
                                        CNLoadAll oTemp = new CNLoadAll(); // Create new object of necessary type

                                        oTemp = (CNLoadAll)(TopoModel.m_arrNLoads[i]); // Change object type

                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFX] = oTemp.Value_FX;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFY] = oTemp.Value_FY;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFZ] = oTemp.Value_FZ;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMX] = oTemp.Value_MX;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMY] = oTemp.Value_MY;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMZ] = oTemp.Value_MZ;

                                        /*
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFX] = TopoModel.m_arrNLoads[i].Value_FX;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFY] = TopoModel.m_arrNLoads[i].Value_FY;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFZ] = TopoModel.m_arrNLoads[i].Value_FZ;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMX] = TopoModel.m_arrNLoads[i].Value_MX;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMY] = TopoModel.m_arrNLoads[i].Value_MY;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMZ] = TopoModel.m_arrNLoads[i].Value_MZ;
                                        */
                                    }
                                    else
                                    {
                                        CNLoadSingle oTemp = new CNLoadSingle(); // Create new object of necessary type

                                        oTemp = (CNLoadSingle)(TopoModel.m_arrNLoads[i]); // Change object type

                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFX] = oTemp.NLoadType == ENLoadType.eNLT_Fx ? oTemp.Value : 0.0f;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFY] = oTemp.NLoadType == ENLoadType.eNLT_Fy ? oTemp.Value : 0.0f;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eFZ] = oTemp.NLoadType == ENLoadType.eNLT_Fz ? oTemp.Value : 0.0f;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMX] = oTemp.NLoadType == ENLoadType.eNLT_Mx ? oTemp.Value : 0.0f;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMY] = oTemp.NLoadType == ENLoadType.eNLT_My ? oTemp.Value : 0.0f;
                                        m_arrFemNodes[k].m_VDirNodeLoad.FVectorItems[(int)e3D_E_F.eMZ] = oTemp.NLoadType == ENLoadType.eNLT_Mz ? oTemp.Value : 0.0f;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // Member loads

            // Set primary end forces only due to member loads in local coordinate system LCS
            // Summation of loads applied on one member
            // There can by more loads on one member, member could be in various loads lists (but only once in one list)

            if (!object.ReferenceEquals(null, TopoModel.m_arrMLoads))
            {
                for (int i = 0; i < TopoModel.m_arrMLoads.Length; i++) // Each load
                {
                    if (TopoModel.m_arrMLoads[i].IMemberCollection != null) // Check if some members are in list
                    {
                        for (int j = 0; j < TopoModel.m_arrMLoads[i].IMemberCollection.Length; j++) // Each node in collection
                        {
                            // Set end forces due to member load
                            for (int k = 0; k < m_arrFemMembers.Length; k++) // Neefektivne prechadzat zbytocne vsetky pruty kedze pozname konkretne ID zatazenych
                            {
                                // Temporary value of end forces due to particular external force
                                float fTemp_A_UXRX = 0f, fTemp_B_UXRX = 0f, fTemp_Ma_UXRX = 0f, fTemp_Mb_UXRX = 0f;
                                float fTemp_A_UYRZ = 0f, fTemp_B_UYRZ = 0f, fTemp_Ma_UYRZ = 0f, fTemp_Mb_UYRZ = 0f;
                                float fTemp_A_UZRY = 0f, fTemp_B_UZRY = 0f, fTemp_Ma_UZRY = 0f, fTemp_Mb_UZRY = 0f;

                                // Fill end forces due to external forces vectors for member particular load index i and member index k
                                // Depends on load dirrection and member support type
                                // Use member PRINCIPAL coordinate system
                                CMLoadPart objAux = new CMLoadPart(TopoModel, m_arrFemMembers, i, k,
                                    out fTemp_A_UXRX, out fTemp_Ma_UXRX, out fTemp_A_UYRZ, out fTemp_Ma_UYRZ, out fTemp_A_UZRY, out fTemp_Ma_UZRY,
                                    out fTemp_B_UXRX, out fTemp_Mb_UXRX, out fTemp_B_UYRZ, out fTemp_Mb_UYRZ, out fTemp_B_UZRY, out fTemp_Mb_UZRY
                                );

                                // Add values of temporary end forces due to particular load to the end forces items of vector
                                // Primary end forces due member loading in local coordinate system LCS

                                // Start Node
                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eFX] += fTemp_A_UXRX;
                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eMX] += fTemp_Ma_UXRX;

                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eFY] += fTemp_A_UYRZ; // !!! Signs - nutne skontrolovat znamienka podla smeru lokalnych osi a orientacie zatazenia
                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eMZ] += fTemp_Ma_UYRZ;

                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eFZ] += fTemp_A_UZRY; // !!! Signs - nutne skontrolovat znamienka podla smeru lokalnych osi a orientacie zatazenia
                                m_arrFemMembers[k].m_VElemPEF_LCS_StNode.FVectorItems[(int)e3D_E_F.eMY] += fTemp_Ma_UZRY;

                                // End Node
                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eFX] += fTemp_B_UXRX;
                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eMX] += fTemp_Mb_UXRX;

                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eFY] += fTemp_B_UYRZ; //-fTemp_B_UYRZ;  // Zmena znamienka pre silu Vb na konci pruta, znamienko je opacne nez u reakcie, toto su vsak reakcie
                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eMZ] += fTemp_Mb_UYRZ;

                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eFZ] += fTemp_B_UZRY; //-fTemp_B_UZRY;  // Zmena znamienka pre silu Vb na konci pruta, znamienko je opacne nez u reakcie, toto su vsak reakcie
                                m_arrFemMembers[k].m_VElemPEF_LCS_EnNode.FVectorItems[(int)e3D_E_F.eMY] += fTemp_Mb_UZRY;
                            }
                        }
                    }
                }
            }

            // Set primary end forces only due to member loads in global coordinate system GCS

            foreach (CE_1D Elem in m_arrFemMembers)
            {
                Elem.SetGetPEF_GCS();
            }
        }
예제 #5
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
        // Member 1-3
        public void GetEndLoad_F(CE_1D Element, float fFx, float fFy, float fFz)
        {
            switch (Element.m_eSuppType3D)
            {
                case EElemSuppType3D.e3DEl_000000_000000:
                case EElemSuppType3D.e3DEl_000000_0_00_0:
                case EElemSuppType3D.e3DEl_0_00_0_000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = -0.5f * fFz;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = fFz * Element.FLength / 8f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = -0.5f * fFz;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = -fFz * Element.FLength / 8f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;
                        break;
                    }
                case EElemSuppType3D.e3DEl_000____000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 5f / 16f * fFz;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 11f / 16f * fFz;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = 3f / 16f * fFz * Element.FLength;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;
                        break;
                    }
                case EElemSuppType3D.e3DEl_000000_000___:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 11f / 16f * fFz;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = 3f / 16f * fFz * Element.FLength;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = fFx / 2f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 5f / 16f * fFz;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;
                        break;
                    }
                default:
                    {
                        GetEndLoad(Element);
                        break;
                    }
            }

            // Set Primary End Forces of Elemnent in Global Coordinate system
            SetGetPEF_GCS(Element);

            // Update Element Primary End Forces Vector (1x12) in LCS
            UpdateElemPEF_LCS_Vector(Element);
            // Update Element Primary End Forces Vector (1x12) in GCS
            UpdateElemPEF_GCS_Vector(Element);
        }
예제 #6
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
 // Update Element Primary End Forces Vector (1x12) in LCS
 void UpdateElemPEF_LCS_Vector(CE_1D Element)
 {
     for (int i = 0; i < 6; i++)
     {
         Element.m_ArrElemPEF_LCS.m_fArrMembers[0, i] = Element.m_VElemPEF_LCS_StNode.FVectorItems[i];  // Start Node
         Element.m_ArrElemPEF_LCS.m_fArrMembers[1, i] = Element.m_VElemPEF_LCS_EnNode.FVectorItems[i];  // End Node
     }
 }
예제 #7
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
        // Set vector of ends  primary forces in global coordinate system
        public void SetGetPEF_GCS(CE_1D Element)
        {
            // Start Node
            // [PEF_GCS i] = [A0T] * [PEF_LCS i]
            Element.m_VElemPEF_GCS_StNode = VectorF.fMultiplyMatrVectr(MatrixF.GetTransMatrix(Element.m_fATRMatr3D), Element.m_VElemPEF_LCS_StNode);

            // End Node
            // [PEF_GCS j] = [A0T] * [PEF_LCS j]
            Element.m_VElemPEF_GCS_EnNode = VectorF.fMultiplyMatrVectr(MatrixF.GetTransMatrix(Element.m_fATRMatr3D), Element.m_VElemPEF_LCS_EnNode);
        }
예제 #8
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
        // Member 1-4
        public void GetEndLoad_M(CE_1D Element, float fMx, float fMy, float fMz)
        {
            switch (Element.m_eSuppType3D)
            {
                case EElemSuppType3D.e3DEl_000000_000000:
                case EElemSuppType3D.e3DEl_000000_0_00_0:
                case EElemSuppType3D.e3DEl_0_00_0_000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 9f * fMz / (8f * Element.FLength);
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = fMx / 2f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = fMy * Element.FLength / 12f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = fMz * Element.FLength / 12f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 9f * fMz / (8f * Element.FLength);
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = -fMx / 2f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = -fMy * Element.FLength / 12f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = -fMz * Element.FLength / 12f;

                        break;
                    }
                case EElemSuppType3D.e3DEl_000____000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = -fMx;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = fMy * Element.FLength / 8f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;
                        break;
                    }
                case EElemSuppType3D.e3DEl_000000_000___:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = fMx;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = fMy * Element.FLength / 8f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 9f * fMy / (8f * Element.FLength);

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;
                        break;
                    }
                default:
                    {
                        GetEndLoad(Element);
                        break;
                    }
            }

            // Set Primary End Forces of Elemnent in Global Coordinate system
            SetGetPEF_GCS(Element);

            // Update Element Primary End Forces Vector (1x12) in LCS
            UpdateElemPEF_LCS_Vector(Element);
            // Update Element Primary End Forces Vector (1x12) in GCS
            UpdateElemPEF_GCS_Vector(Element);
        }
예제 #9
0
파일: CLoad.cs 프로젝트: 777ondro/sw-en
        // Member 1-2 - Loaded by uniform load
        public void GetEndLoad_g(CE_1D Element, float fg_z)
        {
            switch (Element.m_eSuppType3D)
            {
                case EElemSuppType3D.e3DEl_000000_000000:
                case EElemSuppType3D.e3DEl_000000_0_00_0:
                case EElemSuppType3D.e3DEl_0_00_0_000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = fg_z * Element.FLength / 2f;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = -fg_z * (float)Math.Pow(Element.FLength, 2f) / 12f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = fg_z * Element.FLength / 2f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = fg_z * (float)Math.Pow(Element.FLength, 2f) / 12f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;

                        break;
                    }
                case EElemSuppType3D.e3DEl_000____000000:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = -3 * fg_z * Element.FLength / 8f;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = 5 * fg_z * Element.FLength / 8f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = fg_z * (float)Math.Pow(Element.FLength, 2f) / 8f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;

                        break;
                    }
                case EElemSuppType3D.e3DEl_000000_000___:
                    {
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[2] = 5 * fg_z * Element.FLength / 8f;

                        Element.m_VElemPEF_LCS_StNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[4] = fg_z * (float)Math.Pow(Element.FLength, 2f) / 8f;
                        Element.m_VElemPEF_LCS_StNode.FVectorItems[5] = 0f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[0] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[1] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[2] = -3 * fg_z * Element.FLength / 8f;

                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[3] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[4] = 0f;
                        Element.m_VElemPEF_LCS_EnNode.FVectorItems[5] = 0f;

                        break;
                    }

                default:
                    {
                        GetEndLoad(Element);
                      break;
                    }
            }

            // Set Primary End Forces of Elemnent in Global Coordinate system
            SetGetPEF_GCS(Element);

            // Update Element Primary End Forces Vector (1x12) in LCS
            UpdateElemPEF_LCS_Vector(Element);
            // Update Element Primary End Forces Vector (1x12) in GCS
            UpdateElemPEF_GCS_Vector(Element);
        }
예제 #10
0
파일: CFemNode.cs 프로젝트: 777ondro/sw-en
        // Function returns list of FEM 1D elements which includes given node
        // Do we need to store whole elements object (array of elements indexes should be enough) !!!
        public ArrayList GetFoundedMembers(CFemNode Node, CE_1D[] ElemArray, int iElemNo)
        {
            int j = 0;
            ArrayList ElemTempList = new ArrayList();

            for (int i = 0; i < iElemNo; i++)
            {
                if ((ElemArray[i].NodeStart == Node) || (ElemArray[i].NodeEnd == Node))
                {
                    ElemTempList.Add(i); // Add Element to Element List
                    j++;
                }
            }

            return ElemTempList;
        }
예제 #11
0
파일: CFemNode.cs 프로젝트: 777ondro/sw-en
        public ArrayList GetFoundedMembers_IndexOld(CFemNode Node, CE_1D[] ElemArray, int iElemNo)
        {
            int j = 0;
            ArrayList IndexList = new ArrayList();

            for (int i = 0; i < iElemNo; i++)
            {
                if ((ElemArray[i].NodeStart == Node) || (ElemArray[i].NodeEnd == Node))
                {
                    IndexList.Add(i); // Add Element to Element Index Array
                    j++;
                }
            }

            return IndexList;
        }
예제 #12
0
파일: CFemNode.cs 프로젝트: 777ondro/sw-en
        // Array of int values
        public ArrayList GetFoundedMembers_Index(CFemNode Node, CE_1D[] ElemArray)
        {
            ArrayList IndexList = new ArrayList();

            for (int i = 0; i < ElemArray.Length; i++) // Check for each member in array
            {
                if ((ElemArray[i].NodeStart == Node) || (ElemArray[i].NodeEnd == Node))
                {
                    IndexList.Add(i); // Add Element to Element Index Array
                }
            }

            return IndexList;
        }