public ContinuumElement3D CreateElement(CellType cellType, IReadOnlyList<Node> nodes,
			ElasticMaterial3D commonMaterial, DynamicMaterial commonDynamicProperties)
		{
			int numGPs = integrationsForStiffness[cellType].IntegrationPoints.Count;
			var materialsAtGaussPoints = new ElasticMaterial3D[numGPs];
			for (int gp = 0; gp < numGPs; ++gp) materialsAtGaussPoints[gp] = commonMaterial.Clone();
			return CreateElement(cellType, nodes, materialsAtGaussPoints, commonDynamicProperties);
		}
Ejemplo n.º 2
0
        public void ContinuumElement3DElasticMaterialDynamicConsistent()
        {
            IList <Node> nodes = new List <Node>();

            // Create Model
            var model = new Model();

            // Create Subdomain
            model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));

            // Create Elastic Material
            var solidMaterial = new ElasticMaterial3D()
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Create Dynamic Material
            var dynamicMaterial = new DynamicMaterial(density, 0, 0, true);

            DefineContinuumElement3DLinear(model, solidMaterial, dynamicMaterial);

            BoundaryConditions(model);

            // Choose linear equation system solver
            var           solverBuilder = new SkylineSolver.Builder();
            SkylineSolver solver        = solverBuilder.BuildSolver(model);

            // Choose the provider of the problem -> here a structural problem
            var provider = new ProblemStructural(model, solver);

            // Choose child analyzer -> Linear
            var childAnalyzer = new LinearAnalyzer(model, solver, provider);

            // Choose parent analyzer -> Parent: Static
            var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 1.0, 100.0);

            parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();
            NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();

            // Request output
            childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });

            // Run the analysis
            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            // Check output
            DOFSLog log           = (DOFSLog)childAnalyzer.Logs[subdomainID][0];
            double  computedValue = log.DOFValues[monitorDof];
            double  expectedValue = 0.531178; // consistent: 0.531178 // lumped: 0.894201

            Assert.Equal(expectedValue, computedValue, 3);
        }
Ejemplo n.º 3
0
            public static void EmbeddedElementsBuilder(Model model)
            {
                // define mechanical properties
                double youngModulus     = 1.0;
                double shearModulus     = 1.0;
                double poissonRatio     = (youngModulus / (2 * shearModulus)) - 1;
                double area             = 1776.65;      // CNT(20,20)-LinearEBE-TBT-L = 10nm
                double inertiaY         = 1058.55;
                double inertiaZ         = 1058.55;
                double torsionalInertia = 496.38;
                double effectiveAreaY   = area;
                double effectiveAreaZ   = area;

                // Geometry
                model.NodesDictionary.Add(9, new Node(id: 9, x: 0.00, y: 0.00, z: 0.00));
                model.NodesDictionary.Add(10, new Node(id: 10, x: 10.00, y: 0.00, z: 0.00));

                // Create new 3D material
                var beamMaterial = new ElasticMaterial3D()
                {
                    YoungModulus = youngModulus,
                    PoissonRatio = poissonRatio,
                };

                // Create new Beam3D section and element
                var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);
                // element nodes
                var elementNodes = new List <Node>();

                elementNodes.Add(model.NodesDictionary[9]);
                elementNodes.Add(model.NodesDictionary[10]);
                var beam        = new Beam3DCorotationalQuaternion(elementNodes, beamMaterial, 7.85, beamSection);
                var beamElement = new Element {
                    ID = 2, ElementType = beam
                };

                beamElement.NodesDictionary.Add(9, model.NodesDictionary[9]);
                beamElement.NodesDictionary.Add(10, model.NodesDictionary[10]);

                model.ElementsDictionary.Add(beamElement.ID, beamElement);
                model.SubdomainsDictionary[1].Elements.Add(beamElement);
            }
        public static (double[], double[], double[], double[], IVector, IVector) Check05bStressIntegrationObje_Integration()
        {
            //Origin: SeparateCodeCheckingClass.Check05bStressIntegration
            //modifications: tha xrhsimopoithei h nea microstructure me obje kapoia subdomainCalculations

            double E_disp = 3.5; /*Gpa*/ double ni_disp = 0.4; // stather Poisson
            var    material1 = new ElasticMaterial3D()
            {
                YoungModulus = E_disp, PoissonRatio = ni_disp,
            };

            double[,] DGtr = new double[3, 3] {
                { 1.10, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            double[] GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            //double[] stressesCheck1 = material1.Stresses;
            double[] stressesCheck1 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2],
                material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };
            DGtr = new double[3, 3] {
                { 1.20, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            material1.SaveState();
            double[] stressesCheck2 = material1.Stresses;

            //VectorExtensions.AssignTotalAffinityCount();
            IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderNonLinear();
            //IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderCheckEnaHexa();

            //IContinuumMaterial3DDefGrad
            var microstructure3 = new MicrostructureDefGrad3D(homogeneousRveBuilder1,
                                                              model => (new SkylineSolver.Builder()).BuildSolver(model), false, 1);

            //IContinuumMaterial3DDefGrad microstructure3copyConsCheck = new Microstructure3copyConsCheckEna(homogeneousRveBuilder1);
            double[,] consCheck1 = new double[6, 6];
            for (int i1 = 0; i1 < 6; i1++)
            {
                for (int i2 = 0; i2 < 6; i2++)
                {
                    consCheck1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            microstructure3.UpdateMaterial(new double[9] {
                1.10, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck3 = microstructure3.Stresses;
            microstructure3.SaveState();
            IVector uInitialFreeDOFs_state1 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            microstructure3.UpdateMaterial(new double[9] {
                1.20, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck4          = microstructure3.Stresses;
            IVector  uInitialFreeDOFs_state2 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state1.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state1.txt");
            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state2.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state2.txt");

            return(stressesCheck1, stressesCheck2, stressesCheck3, stressesCheck4, uInitialFreeDOFs_state1, uInitialFreeDOFs_state2);
        }
        private static void BuildCantileverModel(Model model, double load_value)
        {
            //xrhsimopoiithike to  ParadeigmataElegxwnBuilder.HexaCantileverBuilder(Model model, double load_value)
            // allagh tou element kai tou material

            //ElasticMaterial3DTemp material1 = new ElasticMaterial3DTemp()
            //{
            //    YoungModulus = 1353000,
            //    PoissonRatio = 0.3,
            //};


            //VonMisesMaterial3D material1 = new VonMisesMaterial3D(1353000, 0.30, 1353000, 0.15);
            var material1 = new ElasticMaterial3D()
            {
                PoissonRatio = 0.3, YoungModulus = 1353000
            };

            double[,] nodeData = new double[, ] {
                { -0.250000, -0.250000, -1.000000 },
                { 0.250000, -0.250000, -1.000000 },
                { -0.250000, 0.250000, -1.000000 },
                { 0.250000, 0.250000, -1.000000 },
                { -0.250000, -0.250000, -0.500000 },
                { 0.250000, -0.250000, -0.500000 },
                { -0.250000, 0.250000, -0.500000 },
                { 0.250000, 0.250000, -0.500000 },
                { -0.250000, -0.250000, 0.000000 },
                { 0.250000, -0.250000, 0.000000 },
                { -0.250000, 0.250000, 0.000000 },
                { 0.250000, 0.250000, 0.000000 },
                { -0.250000, -0.250000, 0.500000 },
                { 0.250000, -0.250000, 0.500000 },
                { -0.250000, 0.250000, 0.500000 },
                { 0.250000, 0.250000, 0.500000 },
                { -0.250000, -0.250000, 1.000000 },
                { 0.250000, -0.250000, 1.000000 },
                { -0.250000, 0.250000, 1.000000 },
                { 0.250000, 0.250000, 1.000000 }
            };

            int[,] elementData = new int[, ] {
                { 1, 8, 7, 5, 6, 4, 3, 1, 2 },
                { 2, 12, 11, 9, 10, 8, 7, 5, 6 },
                { 3, 16, 15, 13, 14, 12, 11, 9, 10 },
                { 4, 20, 19, 17, 18, 16, 15, 13, 14 },
            };

            // orismos shmeiwn
            double correction = 10;// +20;

            for (int nNode = 0; nNode < nodeData.GetLength(0); nNode++)
            {
                model.NodesDictionary.Add(nNode + 1, new Node(nNode + 1, nodeData[nNode, 0] + correction, nodeData[nNode, 1] + correction, nodeData[nNode, 2] + correction));
            }

            // orismos elements
            Element e1;
            int     subdomainID = Hexa8Continuum3DLinearCantilever.subdomainID;

            int[] ContinuumHexa8NodesNumbering = new int[8] {
                7, 8, 5, 6, 3, 4, 1, 2
            };                                                                      // { 2, 3, 7, 6, 1, 4, 8, 5 };
            for (int nElement = 0; nElement < elementData.GetLength(0); nElement++)
            {
                DynamicMaterial DynamicMaterial = new DynamicMaterial(1, 0, 0);
                //Dictionary<int,Node3D >
                List <Node> nodeSet = new List <Node>(8);
                for (int j = 0; j < 8; j++)
                {
                    int nodeID = elementData[nElement, j + 1];
                    nodeSet.Add((Node)model.NodesDictionary[nodeID]);
                }


                var factory = new ContinuumElement3DFactory(material1, DynamicMaterial);

                //e1 = factory.CreateElement(CellType3D.Hexa8, nodeSet);
                e1 = new Element()
                {
                    ID          = nElement + 1,
                    ElementType = factory.CreateElement(CellType.Hexa8, nodeSet)  // dixws to e. exoume sfalma enw sto beambuilding oxi//edw kaleitai me ena orisma to Hexa8
                };
                for (int j = 0; j < 8; j++)
                {
                    int nodeID = elementData[nElement, j + 1];
                    e1.NodesDictionary.Add(nodeID, model.NodesDictionary[nodeID]);
                }
                model.ElementsDictionary.Add(e1.ID, e1);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e1);
            }

            // constraint vashh opou z=-1
            for (int k = 1; k < 5; k++)
            {
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
            }

            // fortish korufhs
            Load load1;

            for (int k = 17; k < 21; k++)
            {
                load1 = new Load()
                {
                    Node   = model.NodesDictionary[k],
                    DOF    = StructuralDof.TranslationX,
                    Amount = 1 * load_value
                };
                model.Loads.Add(load1);
            }
        }
        private static void BuildCantileverModel(Model model, double load_value)
        {
            var material1 = new ElasticMaterial3D()
            {
                PoissonRatio = 0.3, YoungModulus = 1353000
            };

            double[,] nodeData = new double[, ] {
                //{-0.250000,-0.250000,-1.000000}, {0.250000,-0.250000,-1.000000}, {-0.250000,0.250000,-1.000000}, {0.250000,0.250000,-1.000000},
                //{-0.250000,-0.250000,-0.500000}, {0.250000,-0.250000,-0.500000}, {-0.250000,0.250000,-0.500000}, {0.250000,0.250000,-0.500000},
                //{-0.250000,-0.250000,0.000000}, {0.250000,-0.250000,0.000000}, {-0.250000,0.250000,0.000000}, {0.250000,0.250000,0.000000},
                //{-0.250000,-0.250000,0.500000}, {0.250000,-0.250000,0.500000}, {-0.250000,0.250000,0.500000}, {0.250000,0.250000,0.500000},
                //{-0.250000,-0.250000,1.000000}, {0.250000,-0.250000,1.000000}, {-0.250000,0.250000,1.000000}, {0.250000,0.250000,1.000000},
                //};

                { -0.250000, -0.250000, -2.000000 }, { 0.250000, -0.250000, -2.000000 }, { -0.250000, 0.250000, -2.000000 }, { 0.250000, 0.250000, -2.000000 },
                { -0.250000, -0.250000, -1.500000 }, { 0.250000, -0.250000, -1.500000 }, { -0.250000, 0.250000, -1.500000 }, { 0.250000, 0.250000, -1.500000 },
                { -0.250000, -0.250000, -1.000000 }, { 0.250000, -0.250000, -1.000000 }, { -0.250000, 0.250000, -1.000000 }, { 0.250000, 0.250000, -1.000000 },
                { -0.250000, -0.250000, -0.500000 }, { 0.250000, -0.250000, -0.500000 }, { -0.250000, 0.250000, -0.500000 }, { 0.250000, 0.250000, -0.500000 },
                { -0.250000, -0.250000, 0.000000 }, { 0.250000, -0.250000, 0.000000 }, { -0.250000, 0.250000, 0.000000 }, { 0.250000, 0.250000, 0.000000 },
                { -0.250000, -0.250000, 0.500000 }, { 0.250000, -0.250000, 0.500000 }, { -0.250000, 0.250000, 0.500000 }, { 0.250000, 0.250000, 0.500000 },
                { -0.250000, -0.250000, 1.000000 }, { 0.250000, -0.250000, 1.000000 }, { -0.250000, 0.250000, 1.000000 }, { 0.250000, 0.250000, 1.000000 },
                { -0.250000, -0.250000, 1.500000 }, { 0.250000, -0.250000, 1.500000 }, { -0.250000, 0.250000, 1.500000 }, { 0.250000, 0.250000, 1.500000 },
                { -0.250000, -0.250000, 2.000000 }, { 0.250000, -0.250000, 2.000000 }, { -0.250000, 0.250000, 2.000000 }, { 0.250000, 0.250000, 2.000000 },
            };

            int[,] elementData = new int[, ] {
                //{1,8,7,5,6,4,3,1,2},
                //{2,12,11,9,10,8,7,5,6},
                //{3,16,15,13,14,12,11,9,10},
                //{4,20,19,17,18,16,15,13,14},

                { 1, 8, 7, 5, 6, 4, 3, 1, 2 },
                { 2, 12, 11, 9, 10, 8, 7, 5, 6 },
                { 3, 16, 15, 13, 14, 12, 11, 9, 10 },
                { 4, 20, 19, 17, 18, 16, 15, 13, 14 },
                { 5, 24, 23, 21, 22, 20, 19, 17, 18 },
                { 6, 28, 27, 25, 26, 24, 23, 21, 22 },
                { 7, 32, 31, 29, 30, 28, 27, 25, 26 },
                { 8, 36, 35, 33, 34, 32, 31, 29, 30 },
            };

            // Put nodes and nodal coordinates in model
            for (int nNode = 0; nNode < nodeData.GetLength(0); nNode++)
            {
                model.NodesDictionary.Add(nNode + 1, new Node(id: nNode + 1, x: nodeData[nNode, 0], y:  nodeData[nNode, 1], z: nodeData[nNode, 2]));
            }

            // Define elements
            Element e1;
            int     subdomainID = Hexa8NonLinearCantilever.subdomainID;

            for (int nElement = 0; nElement < elementData.GetLength(0); nElement++)
            {
                e1 = new Element()
                {
                    ID          = nElement + 1,
                    ElementType = new Hexa8NonLinear(material1, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3)) // dixws to e. exoume sfalma enw sto beambuilding oxi//edw kaleitai me ena orisma to Hexa8
                };
                for (int j = 0; j < 8; j++)
                {
                    e1.NodesDictionary.Add(elementData[nElement, j + 1], model.NodesDictionary[elementData[nElement, j + 1]]);
                }
                model.ElementsDictionary.Add(e1.ID, e1);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e1.ID, e1);
            }

            // Constrain nodes at z = -1
            for (int k = 1; k <= 4; k++)
            {
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
            }

            // Top load
            Load load1;

            //for (int k = 17; k <= 20; k++)
            for (int k = 33; k <= 36; k++)
            {
                load1 = new Load()
                {
                    Node   = model.NodesDictionary[k],
                    DOF    = StructuralDof.TranslationY,
                    Amount = 1 * load_value
                };
                model.Loads.Add(load1);
            }
        }
        private static void BuildCantileverModel(Model model, double load_value)
        {
            //xrhsimopoiithike to  ParadeigmataElegxwnBuilder.HexaCantileverBuilder(Model model, double load_value)
            // allagh tou element kai tou material

            //ElasticMaterial3DTemp material1 = new ElasticMaterial3DTemp()
            //{
            //    YoungModulus = 1353000,
            //    PoissonRatio = 0.3,
            //};


            //VonMisesMaterial3D material1 = new VonMisesMaterial3D(1353000, 0.30, 1353000, 0.15);
            var material1 = new ElasticMaterial3D()
            {
                PoissonRatio = 0.3, YoungModulus = 1353000
            };

            double[,] nodeData = new double[, ] {
                { -0.250000, -0.250000, -1.000000 },
                { 0.250000, -0.250000, -1.000000 },
                { -0.250000, 0.250000, -1.000000 },
                { 0.250000, 0.250000, -1.000000 },
                { -0.250000, -0.250000, -0.500000 },
                { 0.250000, -0.250000, -0.500000 },
                { -0.250000, 0.250000, -0.500000 },
                { 0.250000, 0.250000, -0.500000 },
                { -0.250000, -0.250000, 0.000000 },
                { 0.250000, -0.250000, 0.000000 },
                { -0.250000, 0.250000, 0.000000 },
                { 0.250000, 0.250000, 0.000000 },
                { -0.250000, -0.250000, 0.500000 },
                { 0.250000, -0.250000, 0.500000 },
                { -0.250000, 0.250000, 0.500000 },
                { 0.250000, 0.250000, 0.500000 },
                { -0.250000, -0.250000, 1.000000 },
                { 0.250000, -0.250000, 1.000000 },
                { -0.250000, 0.250000, 1.000000 },
                { 0.250000, 0.250000, 1.000000 }
            };

            int[,] elementData = new int[, ] {
                { 1, 8, 7, 5, 6, 4, 3, 1, 2 },
                { 2, 12, 11, 9, 10, 8, 7, 5, 6 },
                { 3, 16, 15, 13, 14, 12, 11, 9, 10 },
                { 4, 20, 19, 17, 18, 16, 15, 13, 14 },
            };

            // orismos shmeiwn
            for (int nNode = 0; nNode < nodeData.GetLength(0); nNode++)
            {
                model.NodesDictionary.Add(nNode + 1, new Node(id: nNode + 1, x: nodeData[nNode, 0], y: nodeData[nNode, 1], z: nodeData[nNode, 2]));
            }

            // orismos elements
            Element e1;
            int     subdomainID = Hexa8NonLinearCantilever.subdomainID;

            for (int nElement = 0; nElement < elementData.GetLength(0); nElement++)
            {
                e1 = new Element()
                {
                    ID          = nElement + 1,
                    ElementType = new Hexa8NonLinear(material1, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3))                     // dixws to e. exoume sfalma enw sto beambuilding oxi//edw kaleitai me ena orisma to Hexa8
                };
                for (int j = 0; j < 8; j++)
                {
                    e1.NodesDictionary.Add(elementData[nElement, j + 1], model.NodesDictionary[elementData[nElement, j + 1]]);
                }
                model.ElementsDictionary.Add(e1.ID, e1);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e1);
            }

            // constraint vashh opou z=-1
            for (int k = 1; k < 5; k++)
            {
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
            }

            // fortish korufhs
            Load load1;

            for (int k = 17; k < 21; k++)
            {
                load1 = new Load()
                {
                    Node   = model.NodesDictionary[k],
                    DOF    = StructuralDof.TranslationX,
                    Amount = 1 * load_value
                };
                model.Loads.Add(load1);
            }
        }
Ejemplo n.º 8
0
        public static void CNT_4_4_DisplacementControl()
        {
            double youngModulus      = 16710.0;
            double poissonRatio      = 0.034;
            double nodalDisplacement = 23.73;
            double area             = 5.594673861218848e-003;
            double inertiaY         = 2.490804749753243e-006;
            double inertiaZ         = 2.490804749753243e-006;
            double torsionalInertia = inertiaY / 2.0;
            double effectiveAreaY   = area;
            double effectiveAreaZ   = area;

            string workingDirectory     = @"..\..\..\Resources\Beam3DInputFiles";
            string geometryFileName     = "CNT-4-4-L=25-Geometry.inp";
            string connectivityFileName = "CNT-4-4-L=25-ConnMatr.inp";
            int    increments           = 20;

            int nNodes        = File.ReadLines(workingDirectory + '\\' + geometryFileName).Count();
            int nElems        = File.ReadLines(workingDirectory + '\\' + connectivityFileName).Count();
            int monitorNode_1 = nNodes - 1;
            int monitorNode_2 = nNodes;

            // Create new 3D material
            var material_1 = new ElasticMaterial3D
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            var material_2 = new ElasticMaterial3D
            {
                YoungModulus = 100.0 * youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Model creation
            Model model = new Model();

            // Subdomains
            model.SubdomainsDictionary.Add(1, new Subdomain(1));

            // Node creation
            IList <Node> nodes = new List <Node>();

            using (TextReader reader = File.OpenText(workingDirectory + '\\' + geometryFileName))
            {
                for (int i = 0; i < nNodes; i++)
                {
                    string   text   = reader.ReadLine();
                    string[] bits   = text.Split(',');
                    int      nodeID = int.Parse(bits[0]);
                    double   nodeX  = double.Parse(bits[1]);
                    double   nodeY  = double.Parse(bits[2]);
                    double   nodeZ  = double.Parse(bits[3]);
                    nodes.Add(new Node(id: nodeID, x: nodeX, y:  nodeY, z: nodeZ));
                    model.NodesDictionary.Add(nodeID, nodes[i]);
                }
            }

            // Constraints
            IList <Node> constraintsNodes = new List <Node>();

            constraintsNodes.Add(nodes[1 - 1]);
            constraintsNodes.Add(nodes[2 - 1]);
            constraintsNodes.Add(nodes[617 - 1]);
            constraintsNodes.Add(nodes[618 - 1]);
            constraintsNodes.Add(nodes[1029 - 1]);
            constraintsNodes.Add(nodes[1030 - 1]);
            constraintsNodes.Add(nodes[1441 - 1]);
            constraintsNodes.Add(nodes[1442 - 1]);
            constraintsNodes.Add(nodes[1649 - 1]);

            for (int i = 0; i < 9; i++)
            {
                int iNode = constraintsNodes[i].ID;
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.RotationX
                });
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.RotationY
                });
                model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                    DOF = StructuralDof.RotationZ
                });
            }

            // Applied displacement
            model.NodesDictionary[monitorNode_2].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationY, Amount = nodalDisplacement
            });

            // Create new Beam3D section and element
            var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);

            // Generate elements
            using (TextReader reader = File.OpenText(workingDirectory + '\\' + connectivityFileName))
            {
                for (int i = 0; i < (nElems - 16); i++)
                {
                    string   text      = reader.ReadLine();
                    string[] bits      = text.Split(',');
                    int      elementID = int.Parse(bits[0]);
                    int      node1     = int.Parse(bits[1]);
                    int      node2     = int.Parse(bits[2]);
                    // element nodes
                    IList <Node> elementNodes = new List <Node>();
                    elementNodes.Add(model.NodesDictionary[node1]);
                    elementNodes.Add(model.NodesDictionary[node2]);
                    // create element
                    var beam_1  = new Beam3DCorotationalQuaternion(elementNodes, material_1, 7.85, beamSection);
                    var element = new Element {
                        ID = elementID, ElementType = beam_1
                    };
                    // Add nodes to the created element
                    element.AddNode(model.NodesDictionary[node1]);
                    element.AddNode(model.NodesDictionary[node2]);
                    // beam stiffness matrix
                    var a = beam_1.StiffnessMatrix(element);
                    // Add beam element to the element and subdomains dictionary of the model
                    model.ElementsDictionary.Add(element.ID, element);
                    model.SubdomainsDictionary[1].Elements.Add(element);
                }
                for (int i = (nElems - 16); i < nElems; i++)
                {
                    string   text      = reader.ReadLine();
                    string[] bits      = text.Split(',');
                    int      elementID = int.Parse(bits[0]);
                    int      node1     = int.Parse(bits[1]);
                    int      node2     = int.Parse(bits[2]);
                    // element nodes
                    IList <Node> elementNodes = new List <Node>();
                    elementNodes.Add(model.NodesDictionary[node1]);
                    elementNodes.Add(model.NodesDictionary[node2]);
                    // create element
                    var beam_2  = new Beam3DCorotationalQuaternion(elementNodes, material_2, 7.85, beamSection);
                    var element = new Element {
                        ID = elementID, ElementType = beam_2
                    };
                    // Add nodes to the created element
                    element.AddNode(model.NodesDictionary[node1]);
                    element.AddNode(model.NodesDictionary[node2]);
                    // beam stiffness matrix
                    var a = beam_2.StiffnessMatrix(element);
                    // Add beam element to the element and subdomains dictionary of the model
                    model.ElementsDictionary.Add(element.ID, element);
                    model.SubdomainsDictionary[1].Elements.Add(element);
                }
            }

            // Choose linear equation system solver
            var     solverBuilder = new SkylineSolver.Builder();
            ISolver solver        = solverBuilder.BuildSolver(model);

            // Choose the provider of the problem -> here a structural problem
            var provider = new ProblemStructural(model, solver);

            // Choose child analyzer -> Child: NewtonRaphsonNonLinearAnalyzer
            var subdomainUpdaters    = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[1]) };
            var childAnalyzerBuilder = new DisplacementControlAnalyzer.Builder(model, solver, provider, increments);
            var childAnalyzer        = childAnalyzerBuilder.Build();

            // Choose parent analyzer -> Parent: Static
            var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);

            // Request output
            //int monDOF = linearSystems[1].Solution.Length - 5;  //(6 * monitorNode_2 - 4);
            int monDOF = 9841;

            childAnalyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { monDOF });

            // Run the analysis
            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            // Check output
            DOFSLog log = (DOFSLog)childAnalyzer.Logs[1][0]; //There is a list of logs for each subdomain and we want the first one

            Console.WriteLine($"dof = {monDOF}, u = {log.DOFValues[monDOF]}");
            //Assert.Equal(-21.2328445476855, log.DOFValues[monDOF], 8);
        }
Ejemplo n.º 9
0
        public static void MakeCantileverBeam(Model model, double startX, double startY, double startZ, int startNodeID,
                                              int startElementID, int subdomainID)

        {
            int nodeID = startNodeID;

            for (int j = 0; j < 4; j++)
            {
                if (nodeID % 2 == 0)
                {
                    model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: startX, y:  startY + 0.25, z: startZ + 0.25 * (j / 2)));
                }
                else
                {
                    model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: startX, y:  startY, z: startZ + 0.25 * (j / 2)));
                }
                model.NodesDictionary[nodeID].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[nodeID].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[nodeID].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });

                nodeID++;
            }

            for (int i = 0; i < 4; i++)
            {
                for (int k = 0; k < 4; k++)
                {
                    if (nodeID % 2 == 0)
                    {
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: startX + 0.25 * (i + 1), y:  startY + 0.25, z: startZ + 0.25 * (k / 2)));
                    }
                    else
                    {
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: startX + 0.25 * (i + 1), y:  startY, z: startZ + 0.25 * (k / 2)));
                    }
                    nodeID++;
                }
            }

            int     elementID = startElementID;
            Element e;
            var     material = new ElasticMaterial3D()
            {
                YoungModulus = 2.0e7,
                PoissonRatio = 0.3
            };

            for (int i = 0; i < 4; i++)
            {
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Hexa8(material)
                };

                e.NodesDictionary.Add(startNodeID + 4 * i, model.NodesDictionary[startNodeID + 4 * i]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 4, model.NodesDictionary[startNodeID + 4 * i + 4]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 5, model.NodesDictionary[startNodeID + 4 * i + 5]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 1, model.NodesDictionary[startNodeID + 4 * i + 1]);

                e.NodesDictionary.Add(startNodeID + 4 * i + 2, model.NodesDictionary[startNodeID + 4 * i + 2]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 6, model.NodesDictionary[startNodeID + 4 * i + 6]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 7, model.NodesDictionary[startNodeID + 4 * i + 7]);
                e.NodesDictionary.Add(startNodeID + 4 * i + 3, model.NodesDictionary[startNodeID + 4 * i + 3]);

                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e);


                elementID++;
            }
        }
Ejemplo n.º 10
0
        public static (int[], int[], int[]) Check_Graphene_rve_parallel() //palio "Check_Graphene_rve_Obje_Integration()"
        {
            //Origin h methodos Check_Graphene_rve_serial() tou parontos
            //Origin: SeparateCodeCheckingClass4.Check_Graphene_rve_Obje_Integration apo to branch: example/ms_development_nl_elements_merge
            //modifications: update kai tha xrhsimopoithei o GrapheneReinforcedRVEBuilderExample35fe2boundstiffHostTestPostData
            //o opoios exei kai antistoixo ddm: GrapheneReinforcedRVEBuilderExample35fe2boundstiffHostTestPostDataDdm pou tha trexei akrivws apo katw
            //PROSOXH gia na elegxei kai h defterh iteration u_sunol_micro_2 prepei na valoume ston graphenebuilder Addgraphenesheet xwris to bondslip.

            //mporoun na ginoun delete:
            double            E_disp = 3.5; /*Gpa*/ double ni_disp = 0.4; // stather Poisson
            ElasticMaterial3D material1 = new ElasticMaterial3D()
            {
                YoungModulus = E_disp, PoissonRatio = ni_disp,
            };

            double[,] DGtr = new double[3, 3] {
                { 1.10, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            double[] GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            //double[] stressesCheck1 = material1.Stresses;
            double[] stressesCheck1 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2],
                material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };
            DGtr = new double[3, 3] {
                { 1.20, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            material1.SaveState();
            double[] stressesCheck2 = material1.Stresses;

            // den xreiazetai poia VectorExtensions.AssignTotalAffinityCount();
            var grapheneRveBuilder1 = new RveGrShMultipleSeparated(1);
            //IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderCheckEnaHexa();

            // pros to paron
            var ModelAndNodes = grapheneRveBuilder1.GetModelAndBoundaryNodes();

            int[] hexaPrint  = grapheneRveBuilder1.hexaPrint;
            int[] cohePrint  = grapheneRveBuilder1.cohePrint;
            int[] shellPrint = grapheneRveBuilder1.shellPrint;
            return(hexaPrint, cohePrint, shellPrint);

            IContinuumMaterial3DDefGrad microstructure3 = new MicrostructureDefGrad3D(grapheneRveBuilder1,
                                                                                      model => (new SkylineSolver.Builder()).BuildSolver(model), false, 1);

            //IContinuumMaterial3DDefGrad microstructure3copyConsCheck = new Microstructure3copyConsCheckEna(homogeneousRveBuilder1);
            double[,] consCheck1 = new double[6, 6];
            for (int i1 = 0; i1 < 6; i1++)
            {
                for (int i2 = 0; i2 < 6; i2++)
                {
                    consCheck1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            microstructure3.UpdateMaterial(new double[9] {
                1.05, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck3 = microstructure3.Stresses;
            microstructure3.SaveState();
            microstructure3.UpdateMaterial(new double[9] {
                1.10, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck4 = microstructure3.Stresses;
        }
Ejemplo n.º 11
0
        public static (double[], double[], double[, ], IVector, IVector) Check_Graphene_rve_serial() //palio "Check_Graphene_rve_Obje_Integration()"
        {
            //Origin: SeparateCodeCheckingClass4.Check_Graphene_rve_Obje_Integration apo to branch: example/ms_development_nl_elements_merge
            //modifications: update kai tha xrhsimopoithei o GrapheneReinforcedRVEBuilderExample35fe2boundstiffHostTestPostData
            //o opoios exei kai antistoixo ddm: GrapheneReinforcedRVEBuilderExample35fe2boundstiffHostTestPostDataDdm pou tha trexei akrivws apo katw
            //PROSOXH gia na elegxei kai h defterh iteration u_sunol_micro_2 prepei na valoume ston graphenebuilder Addgraphenesheet xwris to bondslip.
            //mporoun na ginoun delete:
            double E_disp = 3.5; /*Gpa*/ double ni_disp = 0.4; // stather Poisson
            var    material1 = new ElasticMaterial3D()
            {
                YoungModulus = E_disp, PoissonRatio = ni_disp,
            };

            double[,] DGtr = new double[3, 3] {
                { 1.10, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            double[] GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            //double[] stressesCheck1 = material1.Stresses;
            double[] stressesCheck1 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2],
                material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };
            DGtr = new double[3, 3] {
                { 1.20, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            material1.SaveState();
            double[] stressesCheck2 = material1.Stresses;

            // den xreiazetai poia VectorExtensions.AssignTotalAffinityCount();
            IRVEbuilder homogeneousRveBuilder1 = new RveGrShMultiple(1);
            //IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderCheckEnaHexa();

            var microstructure3 = new MicrostructureDefGrad3D(homogeneousRveBuilder1,
                                                              model => (new SkylineSolver.Builder()).BuildSolver(model), false, 1);

            //IContinuumMaterial3DDefGrad microstructure3copyConsCheck = new Microstructure3copyConsCheckEna(homogeneousRveBuilder1);
            double[,] consCheck1 = new double[6, 6];
            for (int i1 = 0; i1 < 6; i1++)
            {
                for (int i2 = 0; i2 < 6; i2++)
                {
                    consCheck1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            microstructure3.UpdateMaterial(new double[9] {
                1.05, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck3 = microstructure3.Stresses;
            microstructure3.SaveState();
            IVector uInitialFreeDOFs_state1 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            microstructure3.UpdateMaterial(new double[9] {
                1.10, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck4          = microstructure3.Stresses;
            IVector  uInitialFreeDOFs_state2 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            //PrintUtilities.WriteToFileVector(stressesCheck3, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\stressesCheck3.txt");
            //PrintUtilities.WriteToFileVector(stressesCheck4, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\stressesCheck4.txt");
            //PrintUtilities.WriteToFile(consCheck1, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\consCheck1.txt");
            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state1.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state1.txt");
            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state2.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state2.txt");

            return(stressesCheck3, stressesCheck4, consCheck1, uInitialFreeDOFs_state1, uInitialFreeDOFs_state2);
        }
        private static void BuildCantileverModel(Model model, double load_value)
        {
            //xrhsimopoiithike to  ParadeigmataElegxwnBuilder.HexaCantileverBuilder(Model model, double load_value)
            // allagh tou element kai tou material

            //ElasticMaterial3DTemp material1 = new ElasticMaterial3DTemp()
            //{
            //    YoungModulus = 1353000,
            //    PoissonRatio = 0.3,
            //};


            //VonMisesMaterial3D material1 = new VonMisesMaterial3D(1353000, 0.30, 1353000, 0.15);
            var material1 = new ElasticMaterial3D()
            {
                PoissonRatio = 0.3, YoungModulus = 1353000
            };

            double[,] nodeData = new double[, ] {
                { -0.2500000000000000, 0.2500000000000000, -1.0000000000000000 },
                { 0.2500000000000000, 0.2500000000000000, -1.0000000000000000 },
                { 0.2500000000000000, -0.2500000000000000, -1.0000000000000000 },
                { -0.2500000000000000, -0.2500000000000000, -1.0000000000000000 },
                { -0.2500000000000000, 0.2500000000000000, 1.0000000000000000 },
                { 0.2500000000000000, 0.2500000000000000, 1.0000000000000000 },
                { 0.2500000000000000, -0.2500000000000000, 1.0000000000000000 },
                { -0.2500000000000000, -0.2500000000000000, 1.0000000000000000 },
                { -0.2500000000000000, 0.2500000000000000, 0.0000000000000000 },
                { 0.2500000000000000, 0.2500000000000000, 0.0000000000000000 },
                { 0.2500000000000000, -0.2500000000000000, 0.0000000000000000 },
                { -0.2500000000000000, -0.2500000000000000, 0.0000000000000000 },
                { 0.0000000000000000, 0.2500000000000000, -1.0000000000000000 },
                { 0.2500000000000000, 0.0000000000000000, -1.0000000000000000 },
                { 0.0000000000000000, -0.2500000000000000, -1.0000000000000000 },
                { -0.2500000000000000, 0.0000000000000000, -1.0000000000000000 },
                { 0.0000000000000000, 0.2500000000000000, 1.0000000000000000 },
                { 0.2500000000000000, 0.0000000000000000, 1.0000000000000000 },
                { 0.0000000000000000, -0.2500000000000000, 1.0000000000000000 },
                { -0.2500000000000000, 0.0000000000000000, 1.0000000000000000 },
                { 0.0000000000000000, 0.2500000000000000, 0.0000000000000000 },
                { 0.2500000000000000, 0.0000000000000000, 0.0000000000000000 },
                { 0.0000000000000000, -0.2500000000000000, 0.0000000000000000 },
                { -0.2500000000000000, 0.0000000000000000, 0.0000000000000000 },
                { -0.2500000000000000, 0.2500000000000000, -0.5000000000000000 },
                { 0.2500000000000000, 0.2500000000000000, -0.5000000000000000 },
                { 0.2500000000000000, -0.2500000000000000, -0.5000000000000000 },
                { -0.2500000000000000, -0.2500000000000000, -0.5000000000000000 },
                { -0.2500000000000000, 0.2500000000000000, 0.5000000000000000 },
                { 0.2500000000000000, 0.2500000000000000, 0.5000000000000000 },
                { 0.2500000000000000, -0.2500000000000000, 0.5000000000000000 },
                { -0.2500000000000000, -0.2500000000000000, 0.5000000000000000 },
                { 0.0000000000000000, 0.0000000000000000, -1.0000000000000000 },
                { -0.1250000000000000, 0.1250000000000000, -1.0000000000000000 },
                { 0.1250000000000000, 0.1250000000000000, -1.0000000000000000 },
                { 0.1250000000000000, -0.1250000000000000, -1.0000000000000000 },
                { -0.1250000000000000, -0.1250000000000000, -1.0000000000000000 },
                { 0.0000000000000000, 0.0000000000000000, 1.0000000000000000 },
                { -0.1250000000000000, 0.1250000000000000, 1.0000000000000000 },
                { 0.1250000000000000, 0.1250000000000000, 1.0000000000000000 },
                { 0.1250000000000000, -0.1250000000000000, 1.0000000000000000 },
                { -0.1250000000000000, -0.1250000000000000, 1.0000000000000000 },
                { 0.0000000000000000, 0.0000000000000000, 0.0000000000000000 },
                { -0.1250000000000000, 0.1250000000000000, 0.0000000000000000 },
                { 0.1250000000000000, 0.1250000000000000, 0.0000000000000000 },
                { 0.1250000000000000, -0.1250000000000000, 0.0000000000000000 },
                { -0.1250000000000000, -0.1250000000000000, 0.0000000000000000 },
                { 0.0000000000000000, 0.2500000000000000, -0.5000000000000000 },
                { 0.1250000000000000, 0.2500000000000000, -0.7500000000000000 },
                { -0.1250000000000000, 0.2500000000000000, -0.7500000000000000 },
                { -0.1250000000000000, 0.2500000000000000, -0.2500000000000000 },
                { 0.1250000000000000, 0.2500000000000000, -0.2500000000000000 },
                { 0.2500000000000000, 0.0000000000000000, -0.5000000000000000 },
                { 0.2500000000000000, -0.1250000000000000, -0.7500000000000000 },
                { 0.2500000000000000, 0.1250000000000000, -0.7500000000000000 },
                { 0.2500000000000000, 0.1250000000000000, -0.2500000000000000 },
                { 0.2500000000000000, -0.1250000000000000, -0.2500000000000000 },
                { 0.0000000000000000, -0.2500000000000000, -0.5000000000000000 },
                { -0.1250000000000000, -0.2500000000000000, -0.7500000000000000 },
                { 0.1250000000000000, -0.2500000000000000, -0.7500000000000000 },
                { 0.1250000000000000, -0.2500000000000000, -0.2500000000000000 },
                { -0.1250000000000000, -0.2500000000000000, -0.2500000000000000 },
                { -0.2500000000000000, 0.0000000000000000, -0.5000000000000000 },
                { -0.2500000000000000, 0.1250000000000000, -0.7500000000000000 },
                { -0.2500000000000000, -0.1250000000000000, -0.7500000000000000 },
                { -0.2500000000000000, -0.1250000000000000, -0.2500000000000000 },
                { -0.2500000000000000, 0.1250000000000000, -0.2500000000000000 },
                { 0.0000000000000000, 0.2500000000000000, 0.5000000000000000 },
                { 0.1250000000000000, 0.2500000000000000, 0.2500000000000000 },
                { -0.1250000000000000, 0.2500000000000000, 0.2500000000000000 },
                { -0.1250000000000000, 0.2500000000000000, 0.7500000000000000 },
                { 0.1250000000000000, 0.2500000000000000, 0.7500000000000000 },
                { 0.2500000000000000, 0.0000000000000000, 0.5000000000000000 },
                { 0.2500000000000000, -0.1250000000000000, 0.2500000000000000 },
                { 0.2500000000000000, 0.1250000000000000, 0.2500000000000000 },
                { 0.2500000000000000, 0.1250000000000000, 0.7500000000000000 },
                { 0.2500000000000000, -0.1250000000000000, 0.7500000000000000 },
                { 0.0000000000000000, -0.2500000000000000, 0.5000000000000000 },
                { -0.1250000000000000, -0.2500000000000000, 0.2500000000000000 },
                { 0.1250000000000000, -0.2500000000000000, 0.2500000000000000 },
                { 0.1250000000000000, -0.2500000000000000, 0.7500000000000000 },
                { -0.1250000000000000, -0.2500000000000000, 0.7500000000000000 },
                { -0.2500000000000000, 0.0000000000000000, 0.5000000000000000 },
                { -0.2500000000000000, 0.1250000000000000, 0.2500000000000000 },
                { -0.2500000000000000, -0.1250000000000000, 0.2500000000000000 },
                { -0.2500000000000000, -0.1250000000000000, 0.7500000000000000 },
                { -0.2500000000000000, 0.1250000000000000, 0.7500000000000000 },
                { 0.0000000000000000, 0.0000000000000000, -0.5000000000000000 },
                { -0.1250000000000000, 0.1250000000000000, -0.7500000000000000 },
                { 0.1250000000000000, 0.1250000000000000, -0.7500000000000000 },
                { 0.1250000000000000, -0.1250000000000000, -0.7500000000000000 },
                { -0.1250000000000000, -0.1250000000000000, -0.7500000000000000 },
                { -0.1250000000000000, 0.1250000000000000, -0.2500000000000000 },
                { 0.1250000000000000, 0.1250000000000000, -0.2500000000000000 },
                { 0.1250000000000000, -0.1250000000000000, -0.2500000000000000 },
                { -0.1250000000000000, -0.1250000000000000, -0.2500000000000000 },
                { 0.0000000000000000, 0.0000000000000000, -0.7500000000000000 },
                { 0.0000000000000000, 0.1250000000000000, -0.5000000000000000 },
                { 0.1250000000000000, 0.0000000000000000, -0.5000000000000000 },
                { 0.0000000000000000, -0.1250000000000000, -0.5000000000000000 },
                { -0.1250000000000000, 0.0000000000000000, -0.5000000000000000 },
                { 0.0000000000000000, 0.0000000000000000, -0.2500000000000000 },
                { 0.0000000000000000, 0.0000000000000000, 0.5000000000000000 },
                { -0.1250000000000000, 0.1250000000000000, 0.2500000000000000 },
                { 0.1250000000000000, 0.1250000000000000, 0.2500000000000000 },
                { 0.1250000000000000, -0.1250000000000000, 0.2500000000000000 },
                { -0.1250000000000000, -0.1250000000000000, 0.2500000000000000 },
                { -0.1250000000000000, 0.1250000000000000, 0.7500000000000000 },
                { 0.1250000000000000, 0.1250000000000000, 0.7500000000000000 },
                { 0.1250000000000000, -0.1250000000000000, 0.7500000000000000 },
                { -0.1250000000000000, -0.1250000000000000, 0.7500000000000000 },
                { 0.0000000000000000, 0.0000000000000000, 0.2500000000000000 },
                { 0.0000000000000000, 0.1250000000000000, 0.5000000000000000 },
                { 0.1250000000000000, 0.0000000000000000, 0.5000000000000000 },
                { 0.0000000000000000, -0.1250000000000000, 0.5000000000000000 },
                { -0.1250000000000000, 0.0000000000000000, 0.5000000000000000 },
                { 0.0000000000000000, 0.0000000000000000, 0.7500000000000000 },
            };

            //int[] take_msolve_nodes_from_adina_tade_nodes = new int[] { 2, 1, 3, 0, 5, 7, 8, 6, 9, 4 };

            int[,] elementData = new int[, ] {
                { 33, 2, 1, 88, 35, 13, 34, 90, 89, 97 },
                { 33, 3, 2, 88, 36, 14, 35, 91, 90, 97 },
                { 33, 4, 3, 88, 37, 15, 36, 92, 91, 97 },
                { 33, 1, 4, 88, 34, 16, 37, 89, 92, 97 },
                { 48, 1, 2, 88, 50, 13, 49, 89, 90, 98 },
                { 48, 2, 10, 88, 49, 26, 52, 90, 94, 98 },
                { 48, 10, 9, 88, 52, 21, 51, 94, 93, 98 },
                { 48, 9, 1, 88, 51, 25, 50, 93, 89, 98 },
                { 53, 2, 3, 88, 55, 14, 54, 90, 91, 99 },
                { 53, 3, 11, 88, 54, 27, 57, 91, 95, 99 },
                { 53, 11, 10, 88, 57, 22, 56, 95, 94, 99 },
                { 53, 10, 2, 88, 56, 26, 55, 94, 90, 99 },
                { 58, 3, 4, 88, 60, 15, 59, 91, 92, 100 },
                { 58, 11, 3, 88, 61, 27, 60, 95, 91, 100 },
                { 58, 12, 11, 88, 62, 23, 61, 96, 95, 100 },
                { 58, 4, 12, 88, 59, 28, 62, 92, 96, 100 },
                { 63, 4, 1, 88, 65, 16, 64, 92, 89, 101 },
                { 63, 12, 4, 88, 66, 28, 65, 96, 92, 101 },
                { 63, 9, 12, 88, 67, 24, 66, 93, 96, 101 },
                { 63, 1, 9, 88, 64, 25, 67, 89, 93, 101 },
                { 43, 9, 10, 88, 44, 21, 45, 93, 94, 102 },
                { 43, 10, 11, 88, 45, 22, 46, 94, 95, 102 },
                { 43, 11, 12, 88, 46, 23, 47, 95, 96, 102 },
                { 43, 12, 9, 88, 47, 24, 44, 96, 93, 102 },
                { 43, 10, 9, 103, 45, 21, 44, 105, 104, 112 },
                { 43, 11, 10, 103, 46, 22, 45, 106, 105, 112 },
                { 43, 12, 11, 103, 47, 23, 46, 107, 106, 112 },
                { 43, 9, 12, 103, 44, 24, 47, 104, 107, 112 },
                { 68, 9, 10, 103, 70, 21, 69, 104, 105, 113 },
                { 68, 10, 6, 103, 69, 30, 72, 105, 109, 113 },
                { 68, 6, 5, 103, 72, 17, 71, 109, 108, 113 },
                { 68, 5, 9, 103, 71, 29, 70, 108, 104, 113 },
                { 73, 10, 11, 103, 75, 22, 74, 105, 106, 114 },
                { 73, 11, 7, 103, 74, 31, 77, 106, 110, 114 },
                { 73, 7, 6, 103, 77, 18, 76, 110, 109, 114 },
                { 73, 6, 10, 103, 76, 30, 75, 109, 105, 114 },
                { 78, 11, 12, 103, 80, 23, 79, 106, 107, 115 },
                { 78, 7, 11, 103, 81, 31, 80, 110, 106, 115 },
                { 78, 8, 7, 103, 82, 19, 81, 111, 110, 115 },
                { 78, 12, 8, 103, 79, 32, 82, 107, 111, 115 },
                { 83, 12, 9, 103, 85, 24, 84, 107, 104, 116 },
                { 83, 8, 12, 103, 86, 32, 85, 111, 107, 116 },
                { 83, 5, 8, 103, 87, 20, 86, 108, 111, 116 },
                { 83, 9, 5, 103, 84, 29, 87, 104, 108, 116 },
                { 38, 5, 6, 103, 39, 17, 40, 108, 109, 117 },
                { 38, 6, 7, 103, 40, 18, 41, 109, 110, 117 },
                { 38, 7, 8, 103, 41, 19, 42, 110, 111, 117 },
                { 38, 8, 5, 103, 42, 20, 39, 111, 108, 117 },
            };

            // orismos shmeiwn
            for (int nNode = 0; nNode < nodeData.GetLength(0); nNode++)
            {
                model.NodesDictionary.Add(nNode + 1, new Node(id: nNode + 1, x: nodeData[nNode, 0], y:  nodeData[nNode, 1], z: nodeData[nNode, 2]));
            }

            // orismos elements
            Element e1;
            var     adinaOrder  = new AdinaElementLocalNodeOrdering();
            int     subdomainID = Tet10ContinuumNonLinearCantilever.subdomainID;

            for (int nElement = 0; nElement < elementData.GetLength(0); nElement++)
            {
                DynamicMaterial DynamicMaterial = new DynamicMaterial(1, 0, 0);
                //Dictionary<int,Node3D >
                List <Node> nodeSet = new List <Node>(10);
                for (int j = 0; j < 10; j++)
                {
                    int nodeID = elementData[nElement, j];
                    nodeSet.Add((Node)model.NodesDictionary[nodeID]);
                }

                var factory = new ContinuumElement3DFactory(material1, DynamicMaterial);

                var nodeSet1 = adinaOrder.ReorderNodes(nodeSet, CellType.Tet10);
                e1 = new Element()
                {
                    ID          = nElement + 1,
                    ElementType = factory.CreateNonLinearElement(CellType.Tet10, nodeSet1, material1, DynamicMaterial)
                };

                for (int j = 0; j < 10; j++)
                {
                    int LocalNode = adinaOrder.GetNodeForLocalMsolveNode(j, CellType.Tet10);
                    e1.NodesDictionary.Add(elementData[nElement, LocalNode], model.NodesDictionary[elementData[nElement, LocalNode]]);
                }

                model.ElementsDictionary.Add(e1.ID, e1);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e1);
            }

            int[] constrainedIds = new int[] { 1, 2, 3, 4, 13, 14, 15, 16, 33, 34, 35, 36, 37 };

            for (int k1 = 0; k1 < constrainedIds.Length; k1++)
            {
                int k = constrainedIds[k1];
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
            }

            // fortish korufhs
            Load load1;

            for (int k = 5; k < 9; k++)
            {
                load1 = new Load()
                {
                    Node   = model.NodesDictionary[k],
                    DOF    = StructuralDof.TranslationX,
                    Amount = 1 * load_value
                };
                model.Loads.Add(load1);
            }
        }
Ejemplo n.º 13
0
        static void Main(string[] args)
        {
            VectorExtensions.AssignTotalAffinityCount();
            double youngModulus = 200.0e06;
            double poissonRatio = 0.3;
            double nodalLoad    = 25.0;

            // Create a new elastic 3D material
            ElasticMaterial3D material = new ElasticMaterial3D()
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Node creation
            IList <Node> nodes = CreateNodes();

            // Model creation
            Model model = new Model();

            // Add a single subdomain to the model
            model.SubdomainsDictionary.Add(1, new Subdomain()
            {
                ID = 1
            });

            // Add nodes to the nodes dictonary of the model
            for (int i = 0; i < nodes.Count; ++i)
            {
                model.NodesDictionary.Add(i + 1, nodes[i]);
            }

            // Constraint bottom nodes of the model
            model.NodesDictionary[1].Constraints.Add(DOFType.X);
            model.NodesDictionary[1].Constraints.Add(DOFType.Y);
            model.NodesDictionary[1].Constraints.Add(DOFType.Z);
            model.NodesDictionary[2].Constraints.Add(DOFType.X);
            model.NodesDictionary[2].Constraints.Add(DOFType.Y);
            model.NodesDictionary[2].Constraints.Add(DOFType.Z);
            model.NodesDictionary[3].Constraints.Add(DOFType.X);
            model.NodesDictionary[3].Constraints.Add(DOFType.Y);
            model.NodesDictionary[3].Constraints.Add(DOFType.Z);
            model.NodesDictionary[4].Constraints.Add(DOFType.X);
            model.NodesDictionary[4].Constraints.Add(DOFType.Y);
            model.NodesDictionary[4].Constraints.Add(DOFType.Z);


            // Create a new Hexa8 element
            var element = new Element()
            {
                ID          = 1,
                ElementType = new Hexa8(material)
            };

            // Add nodes to the created element
            element.AddNode(model.NodesDictionary[1]);
            element.AddNode(model.NodesDictionary[2]);
            element.AddNode(model.NodesDictionary[3]);
            element.AddNode(model.NodesDictionary[4]);
            element.AddNode(model.NodesDictionary[5]);
            element.AddNode(model.NodesDictionary[6]);
            element.AddNode(model.NodesDictionary[7]);
            element.AddNode(model.NodesDictionary[8]);

            // Add Hexa element to the element and subdomains dictionary of the model
            model.ElementsDictionary.Add(element.ID, element);
            model.SubdomainsDictionary[1].ElementsDictionary.Add(element.ID, element);

            // Add nodal load values at the top nodes of the model
            model.Loads.Add(new Load()
            {
                Amount = -nodalLoad, Node = model.NodesDictionary[5], DOF = DOFType.Z
            });
            model.Loads.Add(new Load()
            {
                Amount = -nodalLoad, Node = model.NodesDictionary[6], DOF = DOFType.Z
            });
            model.Loads.Add(new Load()
            {
                Amount = -nodalLoad, Node = model.NodesDictionary[7], DOF = DOFType.Z
            });
            model.Loads.Add(new Load()
            {
                Amount = -nodalLoad, Node = model.NodesDictionary[8], DOF = DOFType.Z
            });

            // Needed in order to make all the required data structures
            model.ConnectDataStructures();

            // Choose linear equation system solver
            SolverSkyline solver = new SolverSkyline(model);

            // Choose the provider of the problem -> here a structural problem
            ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);

            // Choose parent and child analyzers -> Parent: Static, Child: Linear
            Analyzers.LinearAnalyzer childAnalyzer  = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
            StaticAnalyzer           parentAnalyzer = new StaticAnalyzer(provider, childAnalyzer, solver.SubdomainsDictionary);

            // Choose dof types X, Y, Z to log for node 5
            childAnalyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] {
                model.NodalDOFsDictionary[5][DOFType.X],
                model.NodalDOFsDictionary[5][DOFType.Y],
                model.NodalDOFsDictionary[5][DOFType.Z]
            });

            // Analyze the problem
            parentAnalyzer.BuildMatrices();
            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            // Write results to console
            Console.WriteLine("Writing results for node 5");
            Console.WriteLine("Dof and Values for Displacement X, Y, Z");
            Console.WriteLine(childAnalyzer.Logs[1][0]);
        }
Ejemplo n.º 14
0
        public static bool HexaCantileverBuilderDispControl(Model model, double load_value)
        {
            var material1 = new ElasticMaterial3D()
            {
                YoungModulus = 1353000,
                PoissonRatio = 0.3,
            };

            double[,] nodeData = new double[, ] {
                { -0.250000, -0.250000, -1.000000 },
                { 0.250000, -0.250000, -1.000000 },
                { -0.250000, 0.250000, -1.000000 },
                { 0.250000, 0.250000, -1.000000 },
                { -0.250000, -0.250000, -0.500000 },
                { 0.250000, -0.250000, -0.500000 },
                { -0.250000, 0.250000, -0.500000 },
                { 0.250000, 0.250000, -0.500000 },
                { -0.250000, -0.250000, 0.000000 },
                { 0.250000, -0.250000, 0.000000 },
                { -0.250000, 0.250000, 0.000000 },
                { 0.250000, 0.250000, 0.000000 },
                { -0.250000, -0.250000, 0.500000 },
                { 0.250000, -0.250000, 0.500000 },
                { -0.250000, 0.250000, 0.500000 },
                { 0.250000, 0.250000, 0.500000 },
                { -0.250000, -0.250000, 1.000000 },
                { 0.250000, -0.250000, 1.000000 },
                { -0.250000, 0.250000, 1.000000 },
                { 0.250000, 0.250000, 1.000000 }
            };

            int[,] elementData = new int[, ] {
                { 1, 8, 7, 5, 6, 4, 3, 1, 2 },
                { 2, 12, 11, 9, 10, 8, 7, 5, 6 },
                { 3, 16, 15, 13, 14, 12, 11, 9, 10 },
                { 4, 20, 19, 17, 18, 16, 15, 13, 14 },
            };

            // orismos shmeiwn
            for (int nNode = 0; nNode < nodeData.GetLength(0); nNode++)
            {
                model.NodesDictionary.Add(nNode + 1, new Node(id: nNode + 1, x: nodeData[nNode, 0], y:  nodeData[nNode, 1], z: nodeData[nNode, 2]));
            }

            // orismos elements
            Element e1;
            int     subdomainID = 1;

            for (int nElement = 0; nElement < elementData.GetLength(0); nElement++)
            {
                e1 = new Element()
                {
                    ID          = nElement + 1,
                    ElementType = new Hexa8NonLinear(material1, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3)) // dixws to e. exoume sfalma enw sto beambuilding oxi//edw kaleitai me ena orisma to Hexa8
                };
                for (int j = 0; j < 8; j++)
                {
                    e1.NodesDictionary.Add(elementData[nElement, j + 1], model.NodesDictionary[elementData[nElement, j + 1]]);
                }
                model.ElementsDictionary.Add(e1.ID, e1);
                model.SubdomainsDictionary[subdomainID].Elements.Add(e1);
            }

            // constraint vashh opou z=-1
            for (int k = 1; k < 5; k++)
            {
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
            }

            // thetoume constraint tous prescribed
            //Load load1;
            for (int k = 17; k < 21; k++)
            {
                //load1 = new Load()
                //{
                //    Node = model.NodesDictionary[k],
                //    DOF = DOFType.X,
                //    Amount = 1 * load_value
                //};
                //model.Loads.Add(load1);
                model.NodesDictionary[k].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
            }

            return(true);
        }
        public static (double[], double[], double[, ], IVector, IVector) Check_Graphene_rve_Obje_Integration()
        {
            //Origin: SeparateCodeCheckingClass4.Check05bStressIntegrationObje_Integration parontos
            //modifications: tha xrhsimopoithei o GrapheneBuilder...35...v2 gia epilush enos paradeigmatos GrapheneReinforcedRVEBuilderCHECK
            //gia elegxo twn newn domwn
            //PROSOXH gia na elegxei kai h defterh iteration u_sunol_micro_2 prepei na valoume ston graphenebuilder Addgraphenesheet xwris to bondslip.

            double E_disp = 3.5; /*Gpa*/ double ni_disp = 0.4; // stather Poisson
            var    material1 = new ElasticMaterial3D()
            {
                YoungModulus = E_disp, PoissonRatio = ni_disp,
            };

            double[,] DGtr = new double[3, 3] {
                { 1.10, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            double[] GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            //double[] stressesCheck1 = material1.Stresses;
            double[] stressesCheck1 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2],
                material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };
            DGtr = new double[3, 3] {
                { 1.20, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
            };
            GLVec = Transform_DGtr_to_GLvec(DGtr);
            material1.UpdateMaterial(GLVec);
            material1.SaveState();
            double[] stressesCheck2 = material1.Stresses;

            //VectorExtensions.AssignTotalAffinityCount();
            IRVEbuilder homogeneousRveBuilder1 = new RveGrShOne(1);
            //IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderCheckEnaHexa();

            //IContinuumMaterial3DDefGrad
            var microstructure3 = new MicrostructureDefGrad3D(homogeneousRveBuilder1,
                                                              model => (new SkylineSolver.Builder()).BuildSolver(model), false, 1);

            //IContinuumMaterial3DDefGrad microstructure3copyConsCheck = new Microstructure3copyConsCheckEna(homogeneousRveBuilder1);
            double[,] consCheck1 = new double[6, 6];
            for (int i1 = 0; i1 < 6; i1++)
            {
                for (int i2 = 0; i2 < 6; i2++)
                {
                    consCheck1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            microstructure3.UpdateMaterial(new double[9] {
                1.05, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck3 = microstructure3.Stresses;
            microstructure3.SaveState();
            IVector uInitialFreeDOFs_state1 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            microstructure3.UpdateMaterial(new double[9] {
                1.10, 1, 1, 0, 0, 0, 0, 0, 0
            });
            double[] stressesCheck4          = microstructure3.Stresses;
            IVector  uInitialFreeDOFs_state2 = microstructure3.uInitialFreeDOFDisplacementsPerSubdomain[1].Copy();

            //PrintUtilities.WriteToFileVector(stressesCheck3, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\stressesCheck3.txt");
            //PrintUtilities.WriteToFileVector(stressesCheck4, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\stressesCheck4.txt");
            //PrintUtilities.WriteToFile(consCheck1, @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\consCheck1.txt");
            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state1.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state1.txt");
            //PrintUtilities.WriteToFileVector(uInitialFreeDOFs_state2.CopyToArray(), @"C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\uInitialFreeDOFs_state2.txt");


            return(stressesCheck3, stressesCheck4, consCheck1, uInitialFreeDOFs_state1, uInitialFreeDOFs_state2);
        }
            public static void MatrixModelBuilder(Model model)
            {
                string workingDirectory = @"E:\GEORGE_DATA\DESKTOP\input files"; //@"D:\George\Desktop\input files"; //

                string MatrixGeometryFileName = "MATRIX_3D-L_x=10-L_y=10-L_z=100-1x1x10-Geometry_EBE_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-3x3x10-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-1x1x10-Geometry_EBE_MSolve.inp";

                string MatrixGonnectivityFileName = "MATRIX_3D-L_x=10-L_y=10-L_z=100-1x1x10-ConnMatr_EBE_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-3x3x10-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-1x1x10-ConnMatr_EBE_MSolve.inp";

                int matrixNodes    = File.ReadLines(workingDirectory + '\\' + MatrixGeometryFileName).Count();
                int matrixElements = File.ReadLines(workingDirectory + '\\' + MatrixGonnectivityFileName).Count();

                // Nodes Geometry
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + MatrixGeometryFileName))
                {
                    for (int i = 0; i < matrixNodes; i++)
                    {
                        string   text   = reader.ReadLine();
                        string[] bits   = text.Split(',');
                        int      nodeID = int.Parse(bits[0]);
                        double   nodeX  = double.Parse(bits[1]);
                        double   nodeY  = double.Parse(bits[2]);
                        double   nodeZ  = double.Parse(bits[3]);
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: nodeX, y:  nodeY, z: nodeZ));
                    }
                }

                // Create Material
                var solidMaterial = new ElasticMaterial3D()
                {
                    YoungModulus = 1.00,
                    PoissonRatio = 0.30,
                };

                // Generate elements
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + MatrixGonnectivityFileName))
                {
                    for (int i = 0; i < matrixElements; i++)
                    {
                        string   text      = reader.ReadLine();
                        string[] bits      = text.Split(',');
                        int      elementID = int.Parse(bits[0]);
                        int      node1     = int.Parse(bits[1]);
                        int      node2     = int.Parse(bits[2]);
                        int      node3     = int.Parse(bits[3]);
                        int      node4     = int.Parse(bits[4]);
                        int      node5     = int.Parse(bits[5]);
                        int      node6     = int.Parse(bits[6]);
                        int      node7     = int.Parse(bits[7]);
                        int      node8     = int.Parse(bits[8]);
                        // Hexa8NL element definition
                        var hexa8NLelement = new Element()
                        {
                            ID          = elementID,
                            ElementType = new Hexa8NonLinear(solidMaterial, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3))
                        };
                        // Add nodes to the created element
                        hexa8NLelement.AddNode(model.NodesDictionary[node1]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node2]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node3]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node4]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node5]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node6]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node7]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node8]);
                        // Add Hexa element to the element and subdomains dictionary of the model
                        model.ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                        //model.SubdomainsDictionary[0].ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                        model.SubdomainsDictionary[0].Elements.Add(hexa8NLelement);
                    }
                }

                // Boundary Conditions - Left End [End-1]
                for (int iNode = 1; iNode <= 4; iNode++)
                {
                    //model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.X });
                    //model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.Y });
                    model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                        DOF = StructuralDof.TranslationZ
                    });
                }

                // Boundary Conditions - Bottom End [End-3]
                for (int iNode = 1; iNode <= 41; iNode += 4)
                {
                    for (int j = 0; j < 2; j++)
                    {
                        model.NodesDictionary[iNode + j].Constraints.Add(new Constraint {
                            DOF = StructuralDof.TranslationY
                        });
                    }
                }

                // Boundary Conditions - Bottom End [End-5]
                for (int iNode = 1; iNode <= 43; iNode += 2)
                {
                    model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                        DOF = StructuralDof.TranslationX
                    });
                }

                // Boundary Conditions - Bottom End [End-6]
                for (int iNode = 2; iNode <= 44; iNode += 2)
                {
                    model.NodesDictionary[iNode].Constraints.Add(new Constraint {
                        DOF = StructuralDof.TranslationX
                    });
                }

                // Add nodal load values at the top nodes of the model
                //for (int iNode = 161; iNode <= 164; iNode++) //(int iNode = 338001; iNode <= 338026; iNode++) //(int iNode = 3601; iNode <= 3606; iNode++) //(int iNode = 2603551; iNode < 2603601; iNode++)
                //{
                //    model.Loads.Add(new Load() { Amount = nodalLoad, Node = model.NodesDictionary[iNode], DOF = DOFType.Y });
                //}
                //model.Loads.Add(new Load() { Amount = nodalLoad, Node = model.NodesDictionary[1801], DOF = DOFType.Y });
                //model.Loads.Add(new Load() { Amount = 2, Node = model.NodesDictionary[1802], DOF = DOFType.Y });
                //model.Loads.Add(new Load() { Amount = 2, Node = model.NodesDictionary[1803], DOF = DOFType.Y });
                //model.Loads.Add(new Load() { Amount = 2, Node = model.NodesDictionary[1804], DOF = DOFType.Y });
                //model.Loads.Add(new Load() { Amount = 2, Node = model.NodesDictionary[1805], DOF = DOFType.Y });
                //model.Loads.Add(new Load() { Amount = nodalLoad, Node = model.NodesDictionary[1806], DOF = DOFType.Y });

                // Compression Loading
                double nodalLoad = -25.0;                  //0.40;

                for (int iNode = 41; iNode <= 44; iNode++) //[End-4]
                {
                    model.Loads.Add(new Load()
                    {
                        Amount = nodalLoad, Node = model.NodesDictionary[iNode], DOF = StructuralDof.TranslationZ
                    });
                }

                //// Applied Displacements
                //double nodalDisplacement = -10.0;
                //for (int iNode = 41; iNode <= 44; iNode++) //[End-4]
                //{
                //    model.NodesDictionary[iNode].Constraints.Add(new Constraint { DOF = DOFType.Z, Amount = nodalDisplacement });
                //}
            }
            public static void EBEModelBuilder(Model model)
            {
                // define mechanical properties
                double youngModulus = 1.0;
                double shearModulus = 1.0;
                double poissonRatio = 0.034;  //0.30; // (youngModulus / (2 * shearModulus)) - 1;
                double area         = 694.77; //CNT(8,8)-LinearEBE-TBT-L=10nm
                //1218.11; //CNT(8,8)-LinearEBE-EBT-L=10nm
                //694.77; //CNT(8,8)-LinearEBE-TBT-L=10nm

                double inertiaY = 100.18; //CNT(8,8)-LinearEBE-TBT-L=10nm
                //177.51; //CNT(8,8)-LinearEBE-EBT-L=10nm
                //100.18; //CNT(8,8)-LinearEBE-TBT-L=10nm

                double inertiaZ = 100.18; //CNT(8,8)-LinearEBE-TBT-L=10nm
                //177.51; //CNT(8,8)-LinearEBE-EBT-L=10nm
                //100.18; //CNT(8,8)-LinearEBE-TBT-L=10nm

                double torsionalInertia = 68.77; //CNT(8,8)-LinearEBE-TBT-L=10nm
                //168.25; //CNT(8,8)-LinearEBE-EBT-L=10nm
                //68.77; //CNT(8,8)-LinearEBE-TBT-L=10nm

                double effectiveAreaY   = area;
                double effectiveAreaZ   = area;
                string workingDirectory = @"E:\GEORGE_DATA\DESKTOP\input files"; //@"D:\George\Desktop\input files"; //

                string CNTgeometryFileName = "EmbeddedCNT-8-8-L=100-h=3-k=1-EBE-L=10-NumberOfCNTs=1-Geometry_beam.inp";

                string CNTconnectivityFileName = "EmbeddedCNT-8-8-L=100-h=3-k=1-EBE-L=10-NumberOfCNTs=1-ConnMatr_beam.inp";

                int CNTNodes = File.ReadLines(workingDirectory + '\\' + CNTgeometryFileName).Count();
                int CNTElems = File.ReadLines(workingDirectory + '\\' + CNTconnectivityFileName).Count();

                // Geometry
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + CNTgeometryFileName))
                {
                    for (int i = 0; i < CNTNodes; i++)
                    {
                        string   text   = reader.ReadLine();
                        string[] bits   = text.Split(',');
                        int      nodeID = int.Parse(bits[0]) + 44; // matrixNodes
                        double   nodeX  = double.Parse(bits[1]);
                        double   nodeY  = double.Parse(bits[2]);
                        double   nodeZ  = double.Parse(bits[3]);
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: nodeX, y:  nodeY, z: nodeZ));
                    }
                }

                // Create new 3D material
                var beamMaterial = new ElasticMaterial3D
                {
                    YoungModulus = youngModulus,
                    PoissonRatio = poissonRatio,
                };

                // Create new Beam3D section and element
                var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);

                // element nodes

                using (TextReader reader = File.OpenText(workingDirectory + '\\' + CNTconnectivityFileName))
                {
                    for (int i = 0; i < CNTElems; i++)
                    {
                        string   text      = reader.ReadLine();
                        string[] bits      = text.Split(',');
                        int      elementID = int.Parse(bits[0]) + 10; // matrixElements
                        int      node1     = int.Parse(bits[1]) + 44; // matrixNodes
                        int      node2     = int.Parse(bits[2]) + 44; // matrixNodes

                        // element nodes
                        var elementNodes = new List <Node>();
                        elementNodes.Add(model.NodesDictionary[node1]);
                        elementNodes.Add(model.NodesDictionary[node2]);
                        // create element
                        var beam_1      = new Beam3DCorotationalQuaternion(elementNodes, beamMaterial, 7.85, beamSection);
                        var beamElement = new Element {
                            ID = elementID, ElementType = beam_1
                        };
                        // Add nodes to the created element
                        beamElement.AddNode(model.NodesDictionary[node1]);
                        beamElement.AddNode(model.NodesDictionary[node2]);
                        // beam stiffness matrix
                        // var a = beam_1.StiffnessMatrix(beamElement);
                        // Add beam element to the element and subdomains dictionary of the model
                        model.ElementsDictionary.Add(beamElement.ID, beamElement);
                        //model.SubdomainsDictionary[0].ElementsDictionary.Add(beamElement.ID, beamElement);
                        model.SubdomainsDictionary[0].Elements.Add(beamElement);
                    }
                }
            }
		public ContinuumElement3DFactory(ElasticMaterial3D commonMaterial, DynamicMaterial commonDynamicProperties)
		{
			this.commonDynamicProperties = commonDynamicProperties;
			this.commonMaterial = commonMaterial;
		}
        public static void WriteStiffnessOfContinuum3DStructure()
        {
            //    _____ ____
            //   /    /    /|
            //  /____/____/ |
            //  |    |    | |
            //  |____|____|/|
            //  |    |    | /
            //  |____|____|/
            //

            // Model with 1 subdomain
            var model = new Model();

            model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));

            // Material
            var material = new ElasticMaterial3D()
            {
                YoungModulus = 2.1E7,
                PoissonRatio = 0.3
            };
            var dynamicProperties = new DynamicMaterial(1.0, 0.0, 0.0, true);

            // Generate mesh
            double lengthX       = 2.0;
            double lengthY       = 2.4;
            double lengthZ       = 2.2;
            var    meshGenerator = new UniformMeshGenerator3D <Node>(0.0, 0.0, 0.0, lengthX, lengthY, lengthZ, 10, 10, 10);

            (IReadOnlyList <Node> vertices, IReadOnlyList <CellConnectivity <Node> > cells) =
                meshGenerator.CreateMesh((id, x, y, z) => new Node(id: id, x: x, y:  y, z: z));

            // Add nodes to the model
            for (int n = 0; n < vertices.Count; ++n)
            {
                model.NodesDictionary.Add(n, vertices[n]);
            }

            // Add Quad4 elements to the model
            var factory = new ContinuumElement3DFactory(material, dynamicProperties);

            for (int e = 0; e < cells.Count; ++e)
            {
                ContinuumElement3D element = factory.CreateElement(cells[e].CellType, cells[e].Vertices);
                var elementWrapper         = new Element()
                {
                    ID = e, ElementType = element
                };
                foreach (Node node in element.Nodes)
                {
                    elementWrapper.AddNode(node);
                }
                model.ElementsDictionary.Add(e, elementWrapper);
                model.SubdomainsDictionary[subdomainID].Elements.Add(elementWrapper);
            }

            // Solver
            var           solverBuilder = new SkylineSolver.Builder();
            SkylineSolver solver        = solverBuilder.BuildSolver(model);

            // Structural problem provider
            var provider = new ProblemStructural(model, solver);

            // Linear static analysis
            var childAnalyzer  = new LinearAnalyzer(model, solver, provider);
            var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);

            // Run the analysis to build the stiffness matrix
            parentAnalyzer.Initialize();
            parentAnalyzer.BuildMatrices();

            // Print the stiffness matrix
            //var writer = new MatlabWriter();
            var writer = new RawArraysWriter();

            writer.WriteToMultipleFiles((SkylineMatrix)solver.LinearSystems[subdomainID].Matrix,
                                        outputDirectory + @"\hexa8_10x10x10_stiffness.txt");
        }
            public static void HostElementsBuilder(Model model)
            {
                // Nodes Geometry
                model.NodesDictionary.Add(1, new Node(id: 1, x: 10.00, y:   2.50, z:  2.50));
                model.NodesDictionary.Add(2, new Node(id: 2, x:  0.00, y:   2.50, z:  2.50));
                model.NodesDictionary.Add(3, new Node(id: 3, x:  0.00, y:  -2.50, z:  2.50));
                model.NodesDictionary.Add(4, new Node(id: 4, x: 10.00, y:  -2.50, z:  2.50));
                model.NodesDictionary.Add(5, new Node(id: 5, x: 10.00, y:   2.50, z: -2.50));
                model.NodesDictionary.Add(6, new Node(id: 6, x:  0.00, y:   2.50, z: -2.50));
                model.NodesDictionary.Add(7, new Node(id: 7, x:  0.00, y:  -2.50, z: -2.50));
                model.NodesDictionary.Add(8, new Node(id: 8, x: 10.00, y:  -2.50, z: -2.50));

                // Boundary Conditions
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });

                // Create Material
                var solidMaterial = new ElasticMaterial3D()
                {
                    YoungModulus = 3.76,
                    PoissonRatio = 0.3779,
                };

                // Hexa8NL element definition
                var hexa8NLelement = new Element()
                {
                    ID          = 1,
                    ElementType = new Hexa8NonLinear(solidMaterial, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3))
                };

                // Add nodes to the created element
                hexa8NLelement.AddNode(model.NodesDictionary[1]);
                hexa8NLelement.AddNode(model.NodesDictionary[2]);
                hexa8NLelement.AddNode(model.NodesDictionary[3]);
                hexa8NLelement.AddNode(model.NodesDictionary[4]);
                hexa8NLelement.AddNode(model.NodesDictionary[5]);
                hexa8NLelement.AddNode(model.NodesDictionary[6]);
                hexa8NLelement.AddNode(model.NodesDictionary[7]);
                hexa8NLelement.AddNode(model.NodesDictionary[8]);

                // Add Hexa element to the element and subdomains dictionary of the model
                model.ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                model.SubdomainsDictionary[1].Elements.Add(hexa8NLelement);

                // Add nodal load values at the top nodes of the model
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[1], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[4], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[5], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[8], DOF = StructuralDof.TranslationZ
                });
            }
Ejemplo n.º 21
0
            public static void HostElementsBuilder(Model model)
            {
                // Nodes Geometry
                model.NodesDictionary.Add(1, new Node(id: 1, x: 10.00, y: 2.50, z: 2.50));
                model.NodesDictionary.Add(2, new Node(id: 2, x: 0.00, y: 2.50, z: 2.50));
                model.NodesDictionary.Add(3, new Node(id: 3, x: 0.00, y: -2.50, z: 2.50));
                model.NodesDictionary.Add(4, new Node(id: 4, x: 10.00, y: -2.50, z: 2.50));
                model.NodesDictionary.Add(5, new Node(id: 5, x: 10.00, y: 2.50, z: -2.50));
                model.NodesDictionary.Add(6, new Node(id: 6, x: 0.00, y: 2.50, z: -2.50));
                model.NodesDictionary.Add(7, new Node(id: 7, x: 0.00, y: -2.50, z: -2.50));
                model.NodesDictionary.Add(8, new Node(id: 8, x: 10.00, y: -2.50, z: -2.50));

                // Boundary Conditions
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[2].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[3].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[6].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationX
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationY
                });
                model.NodesDictionary[7].Constraints.Add(new Constraint {
                    DOF = StructuralDof.TranslationZ
                });

                // Create Material
                var solidMaterial = new ElasticMaterial3D()
                {
                    YoungModulus = 3.76,
                    PoissonRatio = 0.3779,
                };

                DynamicMaterial DynamicMaterial = new DynamicMaterial(1, 0, 0);
                var             factory         = new ContinuumElement3DFactory(solidMaterial, DynamicMaterial);
                // Hexa8NL element definition
                List <Node> nodeSet = new List <Node>(8);

                for (int j = 1; j < 9; j++)
                {
                    nodeSet.Add((Node)model.NodesDictionary[j]);
                }
                var hexa8NLelement = new Element()
                {
                    ID          = 1,
                    ElementType = // factory.CreateNonLinearElement(CellType.Hexa8, nodeSet, solidMaterial, DynamicMaterial)
                                  new Hexa8NonLinear(solidMaterial, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3))
                                  // = new ContinummElement3DNonLinear(nodeSet, solidMaterial, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3), ISAAR.MSolve.FEM.Interpolation.InterpolationHexa8.UniqueInstance)
                };

                // Add nodes to the created element
                hexa8NLelement.AddNode(model.NodesDictionary[1]);
                hexa8NLelement.AddNode(model.NodesDictionary[2]);
                hexa8NLelement.AddNode(model.NodesDictionary[3]);
                hexa8NLelement.AddNode(model.NodesDictionary[4]);
                hexa8NLelement.AddNode(model.NodesDictionary[5]);
                hexa8NLelement.AddNode(model.NodesDictionary[6]);
                hexa8NLelement.AddNode(model.NodesDictionary[7]);
                hexa8NLelement.AddNode(model.NodesDictionary[8]);

                // Add Hexa element to the element and subdomains dictionary of the model
                model.ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                model.SubdomainsDictionary[1].Elements.Add(hexa8NLelement);

                // Add nodal load values at the top nodes of the model
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[1], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[4], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[5], DOF = StructuralDof.TranslationZ
                });
                model.Loads.Add(new Load()
                {
                    Amount = 25, Node = model.NodesDictionary[8], DOF = StructuralDof.TranslationZ
                });
            }
            public static void HostElementsBuilder(Model model)
            {
                string workingDirectory = @"E:\GEORGE_DATA\DESKTOP\input files"; //"..\..\..\Resources\Beam3DInputFiles";

                string MatrixGeometryFileName = "MATRIX_3D-L_x=10-L_y=10-L_z=100-9x9x100-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-50x50x1000-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-5x5x100-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-25x25x500-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=1-L_y=1-L_z=10-5x5x50-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-3x3x10-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-29x29x100-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-19x19x200-Geometry_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-9x9x100-Geometry_MSolve.inp";

                string MatrixGonnectivityFileName = "MATRIX_3D-L_x=10-L_y=10-L_z=100-9x9x100-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-50x50x1000-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-5x5x100-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=5-L_y=5-L_z=100-25x25x500-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=1-L_y=1-L_z=10-5x5x50-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-3x3x10-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=30-L_y=30-L_z=100-29x29x100-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-19x19x200-ConnMatr_MSolve.inp";
                //"MATRIX_3D-L_x=10-L_y=10-L_z=100-9x9x100-ConnMatr_MSolve.inp";

                int matrixNodes    = File.ReadLines(workingDirectory + '\\' + MatrixGeometryFileName).Count();
                int matrixElements = File.ReadLines(workingDirectory + '\\' + MatrixGonnectivityFileName).Count();

                // Nodes Geometry
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + MatrixGeometryFileName))
                {
                    for (int i = 0; i < matrixNodes; i++)
                    {
                        string   text   = reader.ReadLine();
                        string[] bits   = text.Split(',');
                        int      nodeID = int.Parse(bits[0]);
                        double   nodeX  = double.Parse(bits[1]);
                        double   nodeY  = double.Parse(bits[2]);
                        double   nodeZ  = double.Parse(bits[3]);
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: nodeX, y:  nodeY, z: nodeZ));
                    }
                }

                // Create Material
                var solidMaterial = new ElasticMaterial3D()
                {
                    YoungModulus = 1.00,
                    PoissonRatio = 0.30,
                };

                // Generate elements
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + MatrixGonnectivityFileName))
                {
                    for (int i = 0; i < matrixElements; i++)
                    {
                        string   text      = reader.ReadLine();
                        string[] bits      = text.Split(',');
                        int      elementID = int.Parse(bits[0]);
                        int      node1     = int.Parse(bits[1]);
                        int      node2     = int.Parse(bits[2]);
                        int      node3     = int.Parse(bits[3]);
                        int      node4     = int.Parse(bits[4]);
                        int      node5     = int.Parse(bits[5]);
                        int      node6     = int.Parse(bits[6]);
                        int      node7     = int.Parse(bits[7]);
                        int      node8     = int.Parse(bits[8]);
                        // Hexa8NL element definition
                        var hexa8NLelement = new Element()
                        {
                            ID          = elementID,
                            ElementType = new Hexa8NonLinear(solidMaterial, GaussLegendre3D.GetQuadratureWithOrder(3, 3, 3))
                        };
                        // Add nodes to the created element
                        hexa8NLelement.AddNode(model.NodesDictionary[node1]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node2]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node3]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node4]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node5]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node6]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node7]);
                        hexa8NLelement.AddNode(model.NodesDictionary[node8]);
                        // Add Hexa element to the element and subdomains dictionary of the model
                        model.ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                        //model.SubdomainsDictionary[0].ElementsDictionary.Add(hexa8NLelement.ID, hexa8NLelement);
                        model.SubdomainsDictionary[0].Elements.Add(hexa8NLelement);
                    }
                }
            }
        private static void TestBeam3DElasticNonlinearNewmarkDynamicAnalysisExample()
        {
            double youngModulus     = 21000.0;
            double poissonRatio     = 0.3;
            double nodalLoad        = 20000.0;
            double area             = 91.04;
            double inertiaY         = 2843.0;
            double inertiaZ         = 8091.0;
            double torsionalInertia = 76.57;
            double effectiveAreaY   = 91.04;
            double effectiveAreaZ   = 91.04;
            double density          = 7.85;
            int    nNodes           = 3;
            int    nElems           = 2;
            int    monitorNode      = 3;

            // Create new 3D material
            var material = new ElasticMaterial3D
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Node creation
            IList <Node> nodes = new List <Node>();
            Node         node1 = new Node(id: 1, x: 0.0, y: 0.0, z: 0.0);
            Node         node2 = new Node(id: 2, x: 300.0, y: 0.0, z: 0.0);
            Node         node3 = new Node(id: 3, x: 600.0, y: 0.0, z: 0.0);

            nodes.Add(node1);
            nodes.Add(node2);
            nodes.Add(node3);

            // Model creation
            Model model = new Model();

            // Add a single subdomain to the model
            int subdomainID = 0;

            model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));

            // Add nodes to the nodes dictonary of the model
            for (int i = 0; i < nodes.Count; ++i)
            {
                model.NodesDictionary.Add(i + 1, nodes[i]);
            }

            // Constrain bottom nodes of the model
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationX
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationY
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationZ
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationX
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationY
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationZ
            });
            // Generate elements of the structure
            int iNode = 1;

            for (int iElem = 0; iElem < nElems; iElem++)
            {
                // element nodes
                IList <Node> elementNodes = new List <Node>();
                elementNodes.Add(model.NodesDictionary[iNode]);
                elementNodes.Add(model.NodesDictionary[iNode + 1]);

                // Create new Beam3D section and element
                var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);
                var beam        = new Beam3DCorotationalQuaternion(elementNodes, material, density, beamSection);

                // Create elements
                var element = new Element()
                {
                    ID          = iElem + 1,
                    ElementType = beam
                };

                // Add nodes to the created element
                element.AddNode(model.NodesDictionary[iNode]);
                element.AddNode(model.NodesDictionary[iNode + 1]);

                var a = beam.StiffnessMatrix(element);
                var b = beam.MassMatrix(element);

                // Add beam element to the element and subdomains dictionary of the model
                model.ElementsDictionary.Add(element.ID, element);
                model.SubdomainsDictionary[subdomainID].Elements.Add(element);
                iNode++;
            }

            // Add nodal load values at the top nodes of the model
            model.Loads.Add(new Load()
            {
                Amount = nodalLoad, Node = model.NodesDictionary[monitorNode], DOF = StructuralDof.TranslationY
            });

            // Solver
            var     solverBuilder = new SkylineSolver.Builder();
            ISolver solver        = solverBuilder.BuildSolver(model);

            // Problem type
            var provider = new ProblemStructural(model, solver);

            // Analyzers
            int increments           = 10;
            var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);

            childAnalyzerBuilder.MaxIterationsPerIncrement     = 120;
            childAnalyzerBuilder.NumIterationsForMatrixRebuild = 500;
            //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
            LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
            var parentAnalyzerBuilder         = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 0.28, 3.36);

            parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();             // Not necessary. This is the default
            NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();

            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            Assert.Equal(148.936792350562, solver.LinearSystems[subdomainID].Solution[7], 12);
        }
            public static void EmbeddedElementsBuilder(Model model)
            {
                // define mechanical properties
                double youngModulus     = 16710.0;                  // 5490; //
                double shearModulus     = 8080.0;                   // 871; //
                double poissonRatio     = 2.15;                     // 0.034; //(youngModulus / (2 * shearModulus)) - 1;
                double area             = 5.594673861218848d - 003; // CNT(20,20)-LinearEBE-TBT-L = 10nm
                double inertiaY         = 2.490804749753243D - 006; //1058.55;
                double inertiaZ         = 2.490804749753243D - 006; // 1058.55;
                double torsionalInertia = 4.981609499506486D - 006; //496.38;
                double effectiveAreaY   = area;
                double effectiveAreaZ   = area;
                string workingDirectory = @"E:\GEORGE_DATA\DESKTOP\input files"; //"..\..\..\Resources\Beam3DInputFiles";

                string CNTgeometryFileName = "CNT-8-8-L=100-h=3-Geometry.inp";
                //"CNT-8-8-L=100-Geometry-2.inp";
                //"EmbeddedCNT-8-8-L=100-h=0-k=1-EBE-L=1-NumberOfCNTs=1-Geometry_beam.inp";
                //"CNT-8-8-L=100-h=3-Geometry.inp";

                string CNTconnectivityFileName = "CNT-8-8-L=100-h=3-ConnMatr.inp";
                //"CNT-8-8-L=100-ConnMatr-2.inp";
                //"EmbeddedCNT-8-8-L=100-h=0-k=1-EBE-L=1-NumberOfCNTs=1-ConnMatr_beam.inp";
                //"CNT-8-8-L=100-h=3-ConnMatr.inp";

                int CNTNodes = File.ReadLines(workingDirectory + '\\' + CNTgeometryFileName).Count();
                int CNTElems = File.ReadLines(workingDirectory + '\\' + CNTconnectivityFileName).Count();

                // Geometry
                using (TextReader reader = File.OpenText(workingDirectory + '\\' + CNTgeometryFileName))
                {
                    for (int i = 0; i < CNTNodes; i++)
                    {
                        string   text   = reader.ReadLine();
                        string[] bits   = text.Split(',');
                        int      nodeID = int.Parse(bits[0]) + 10100; // matrixNodes
                        double   nodeX  = double.Parse(bits[1]);
                        double   nodeY  = double.Parse(bits[2]);
                        double   nodeZ  = double.Parse(bits[3]);
                        model.NodesDictionary.Add(nodeID, new Node(id: nodeID, x: nodeX, y:  nodeY, z: nodeZ));
                    }
                }

                // Create new 3D material
                var beamMaterial = new ElasticMaterial3D
                {
                    YoungModulus = youngModulus,
                    PoissonRatio = poissonRatio,
                };

                // Create new Beam3D section and element
                var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);

                // element nodes

                using (TextReader reader = File.OpenText(workingDirectory + '\\' + CNTconnectivityFileName))
                {
                    for (int i = 0; i < CNTElems; i++)
                    {
                        string   text      = reader.ReadLine();
                        string[] bits      = text.Split(',');
                        int      elementID = int.Parse(bits[0]) + 8100;  // matrixElements
                        int      node1     = int.Parse(bits[1]) + 10100; // matrixNodes
                        int      node2     = int.Parse(bits[2]) + 10100; // matrixNodes
                        // element nodes
                        var elementNodes = new List <Node>();
                        elementNodes.Add(model.NodesDictionary[node1]);
                        elementNodes.Add(model.NodesDictionary[node2]);
                        // create element
                        var beam_1      = new Beam3DCorotationalQuaternion(elementNodes, beamMaterial, 7.85, beamSection);
                        var beamElement = new Element {
                            ID = elementID, ElementType = beam_1
                        };
                        // Add nodes to the created element
                        beamElement.AddNode(model.NodesDictionary[node1]);
                        beamElement.AddNode(model.NodesDictionary[node2]);
                        // beam stiffness matrix
                        // var a = beam_1.StiffnessMatrix(beamElement);
                        // Add beam element to the element and subdomains dictionary of the model
                        model.ElementsDictionary.Add(beamElement.ID, beamElement);
                        //model.SubdomainsDictionary[0].ElementsDictionary.Add(beamElement.ID, beamElement);
                        model.SubdomainsDictionary[0].Elements.Add(beamElement);
                    }
                }
            }
Ejemplo n.º 25
0
        public static void Check3DscaleTransitionsAndMicrostructure()
        {
            //Check05c2_3D_StressIntegration
            double E_disp = 3.5; /*Gpa*/ double ni_disp = 0.4; // stather Poisson
            var    material1 = new ElasticMaterial3D()
            {
                YoungModulus = E_disp, PoissonRatio = ni_disp,
            };

            double[] GLVec = new double[6] {
                0.01, 0, 0, 0, 0, 0
            };
            material1.UpdateMaterial(GLVec);
            double[] stressesCheck1 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2], material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };
            //material1.SaveState();
            GLVec = new double[6] {
                0, 0, 0, 0, 0.02, 0
            };
            material1.UpdateMaterial(GLVec);
            double[] stressesCheck2 = new double[6] {
                material1.Stresses[0], material1.Stresses[1], material1.Stresses[2], material1.Stresses[3], material1.Stresses[4], material1.Stresses[5]
            };

            //VectorExtensions.AssignTotalAffinityCount();
            IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderLinear();
            //IRVEbuilder homogeneousRveBuilder1 = new HomogeneousRVEBuilderCheckEnaHexa();

            IContinuumMaterial3D microstructure3 = new Microstructure3D(homogeneousRveBuilder1,
                                                                        model => (new SkylineSolver.Builder()).BuildSolver(model), false, 1);

            //IContinuumMaterial3DDefGrad microstructure3copyConsCheck = new Microstructure3copyConsCheckEna(homogeneousRveBuilder1);
            double[,] consCheck1 = new double[6, 6];
            for (int i1 = 0; i1 < 6; i1++)
            {
                for (int i2 = 0; i2 < 6; i2++)
                {
                    consCheck1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            microstructure3.UpdateMaterial(new double[6] {
                0.010, 0, 0, 0, 0, 0
            });
            double[] stressesCheck3 = new double[6] {
                microstructure3.Stresses[0], microstructure3.Stresses[1], microstructure3.Stresses[2], microstructure3.Stresses[3], microstructure3.Stresses[4], microstructure3.Stresses[5]
            };
            microstructure3.SaveState();
            microstructure3.UpdateMaterial(new double[6] {
                0, 0, 0, 0, 0.020, 0
            });
            double[] stressesCheck4 = new double[6] {
                microstructure3.Stresses[0], microstructure3.Stresses[1], microstructure3.Stresses[2], microstructure3.Stresses[3], microstructure3.Stresses[4], microstructure3.Stresses[5]
            };

            microstructure3.SaveState();
            microstructure3.UpdateMaterial(new double[6] {
                0.030, 0, 0, 0, 0, 0
            });
            double[] stressesCheck5 = new double[6] {
                microstructure3.Stresses[0], microstructure3.Stresses[1], microstructure3.Stresses[2], microstructure3.Stresses[3], microstructure3.Stresses[4], microstructure3.Stresses[5]
            };
            var Matrix1 = Matrix.CreateZero(3, 3); for (int i1 = 0; i1 < 3; i1++)

            {
                for (int i2 = 0; i2 < 3; i2++)
                {
                    Matrix1[i1, i2] = microstructure3.ConstitutiveMatrix[i1, i2];
                }
            }

            Assert.True(NRNLAnalyzerDevelopTest.AreDisplacementsSame(stressesCheck1, stressesCheck3));
            Assert.True(NRNLAnalyzerDevelopTest.AreDisplacementsSame(stressesCheck2, stressesCheck4));
            Assert.True(NRNLAnalyzerDevelopTest.AreDisplacementsSame(new double[6] {
                3 * stressesCheck1[0], 3 * stressesCheck1[1], 3 * stressesCheck1[2], 3 * stressesCheck1[3], 3 * stressesCheck1[4], 3 * stressesCheck1[5]
            },
                                                                     stressesCheck5));
            Assert.True(AreDisplacementsSame(consCheck1, material1.ConstitutiveMatrix));
            Assert.True(AreDisplacementsSame(Matrix1.CopyToArray2D(), material1.ConstitutiveMatrix));
        }
Ejemplo n.º 26
0
        public void ContinuumElement3DNonLinearElasticMaterialDynamicLumped()
        {
            IList <Node> nodes = new List <Node>();

            // Create Model
            var model = new Model();

            // Create Subdomain
            model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID));

            // Create Elastic Material
            var solidMaterial = new ElasticMaterial3D()
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Create Dynamic Material
            var dynamicMaterial = new DynamicMaterial(density, 0, 0, false);

            DefineContinuumElement3DNonLinear(model, solidMaterial, dynamicMaterial);

            BoundaryConditionsNLM(model);

            // Choose linear equation system solver
            var           solverBuilder = new SkylineSolver.Builder();
            SkylineSolver solver        = solverBuilder.BuildSolver(model);

            // Choose the provider of the problem -> here a structural problem
            var provider = new ProblemStructural(model, solver);

            // Choose child analyzer -> Child: NewtonRaphson - LoadControl
            var subdomainUpdaters    = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) };
            var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments)
            {
                MaxIterationsPerIncrement     = 50,
                NumIterationsForMatrixRebuild = 1,
                ResidualTolerance             = 1E-06,
            };
            var childAnalyzer = childAnalyzerBuilder.Build();

            // Choose parent analyzer -> Parent: Static
            var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, 1.0, 100.0);

            parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration();
            NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build();

            // Request output
            childAnalyzer.LogFactories[subdomainID] = new LinearAnalyzerLogFactory(new int[] { monitorDof });

            // Run the analysis
            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            // Check output
            DOFSLog log           = (DOFSLog)childAnalyzer.Logs[subdomainID][0];
            double  computedValue = log.DOFValues[monitorDof];
            double  expectedValue = 2.97084;

            Assert.Equal(expectedValue, computedValue, 3);
        }
        public void CantileverYBeam3DQuaternionNonlinearTest()
        {
            double youngModulus     = 21000.0;
            double poissonRatio     = 0.3;
            double nodalLoad        = 20000.0;
            double area             = 91.04;
            double inertiaY         = 2843.0;
            double inertiaZ         = 8091.0;
            double torsionalInertia = 76.57;
            double effectiveAreaY   = 91.04;
            double effectiveAreaZ   = 91.04;
            int    nNodes           = 3;
            int    nElems           = 2;
            int    monitorNode      = 3;

            // Create new 3D material
            var material = new ElasticMaterial3D
            {
                YoungModulus = youngModulus,
                PoissonRatio = poissonRatio,
            };

            // Node creation
            IList <Node> nodes = new List <Node>();
            Node         node1 = new Node(id: 1, x:   0.0, y:  0.0, z: 0.0);
            Node         node2 = new Node(id: 2, x: 100.0, y:  0.0, z: 0.0);
            Node         node3 = new Node(id: 3, x: 200.0, y:  0.0, z: 0.0);

            nodes.Add(node1);
            nodes.Add(node2);
            nodes.Add(node3);

            // Model creation
            Model model = new Model();

            // Add a single subdomain to the model
            model.SubdomainsDictionary.Add(1, new Subdomain(1));

            // Add nodes to the nodes dictonary of the model
            for (int i = 0; i < nodes.Count; ++i)
            {
                model.NodesDictionary.Add(i + 1, nodes[i]);
            }

            // Constrain bottom nodes of the model
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationX
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationY
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.TranslationZ
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationX
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationY
            });
            model.NodesDictionary[1].Constraints.Add(new Constraint {
                DOF = StructuralDof.RotationZ
            });

            // Generate elements of the structure
            int iNode = 1;

            for (int iElem = 0; iElem < nElems; iElem++)
            {
                // element nodes
                IList <Node> elementNodes = new List <Node>();
                elementNodes.Add(model.NodesDictionary[iNode]);
                elementNodes.Add(model.NodesDictionary[iNode + 1]);

                // Create new Beam3D section and element
                var beamSection = new BeamSection3D(area, inertiaY, inertiaZ, torsionalInertia, effectiveAreaY, effectiveAreaZ);
                var beam        = new Beam3DCorotationalQuaternion(elementNodes, material, 7.85, beamSection);

                // Create elements
                var element = new Element()
                {
                    ID          = iElem + 1,
                    ElementType = beam
                };

                // Add nodes to the created element
                element.AddNode(model.NodesDictionary[iNode]);
                element.AddNode(model.NodesDictionary[iNode + 1]);

                var a = beam.StiffnessMatrix(element);
                //var writer = new FullMatrixWriter();
                //writer.WriteToFile(a, output);


                // Add beam element to the element and subdomains dictionary of the model
                model.ElementsDictionary.Add(element.ID, element);
                model.SubdomainsDictionary[1].Elements.Add(element);
                iNode++;
            }

            // Add nodal load values at the top nodes of the model
            model.Loads.Add(new Load()
            {
                Amount = nodalLoad, Node = model.NodesDictionary[monitorNode], DOF = StructuralDof.TranslationY
            });

            // Solver
            var     solverBuilder = new SkylineSolver.Builder();
            ISolver solver        = solverBuilder.BuildSolver(model);

            // Problem type
            var provider = new ProblemStructural(model, solver);

            // Analyzers
            int increments           = 10;
            var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments);

            childAnalyzerBuilder.ResidualTolerance = 1E-3;
            //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default
            LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build();
            var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer);

            // Request output
            childAnalyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 7 });

            parentAnalyzer.Initialize();
            parentAnalyzer.Solve();

            // Check output
            DOFSLog log = (DOFSLog)childAnalyzer.Logs[1][0]; //There is a list of logs for each subdomain and we want the first one

            Assert.Equal(148.936792350562, log.DOFValues[7], 2);
        }
Ejemplo n.º 28
0
        public static void MakeBeamBuilding(Model model, double startX, double startY, double startZ, double beamWidth, double beamHeight,
                                            int startNodeID, int startElementID, int subdomainID, int floors, bool isInHexaSoil, bool hasPiles)
        {
            const int nodesPerFloor = 18;

            int nodeID = startNodeID;

            // Construct node structure
            if (!isInHexaSoil)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 5; k++)
                    {
                        model.NodesDictionary.Add(nodeID, new Node()
                        {
                            ID = nodeID, X = startX + k * beamWidth, Y = startY, Z = startZ + j * beamWidth
                        });
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.X);
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.Y);
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.Z);
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotX);
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotY);
                        model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotZ);
                        nodeID++;
                    }
                }
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 2 * beamWidth, Y = startY, Z = startZ + 3 * beamWidth
                });
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.X);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Y);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Z);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotX);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotY);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotZ);
                nodeID++;
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 3 * beamWidth, Y = startY, Z = startZ + 3 * beamWidth
                });
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.X);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Y);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Z);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotX);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotY);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotZ);
                nodeID++;
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 4 * beamWidth, Y = startY, Z = startZ + 3 * beamWidth
                });
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.X);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Y);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.Z);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotX);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotY);
                model.NodesDictionary[nodeID].Constraints.Add(DOFType.RotZ);
                nodeID++;
            }

            for (int i = 1; i <= floors; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 5; k++)
                    {
                        model.NodesDictionary.Add(nodeID, new Node()
                        {
                            ID = nodeID, X = startX + k * beamWidth, Y = startY + i * beamHeight, Z = startZ + j * beamWidth
                        });
                        nodeID++;
                    }
                }
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 2 * beamWidth, Y = startY + i * beamHeight, Z = startZ + 3 * beamWidth
                });
                nodeID++;
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 3 * beamWidth, Y = startY + i * beamHeight, Z = startZ + 3 * beamWidth
                });
                nodeID++;
                model.NodesDictionary.Add(nodeID, new Node()
                {
                    ID = nodeID, X = startX + 4 * beamWidth, Y = startY + i * beamHeight, Z = startZ + 3 * beamWidth
                });
                nodeID++;
            }
            List <Node>       groundNodes = new List <Node>();
            int               elementID   = startElementID;
            Element           e;
            int               fibers   = 400;
            double            b        = 0.3;
            double            h        = 0.1;
            ElasticMaterial3D material = new ElasticMaterial3D()
            {
                YoungModulus = 2.1e5,
                PoissonRatio = 0.35,
            };

            if (isInHexaSoil)
            {
                List <Node> sub1Nodes = new List <Node>();
                List <Node> sub2Nodes = new List <Node>();
                // Get ground and sub nodes
                for (int i = 0; i < nodesPerFloor; i++)
                {
                    groundNodes.Add(GetNodeUnderNode(model, model.NodesDictionary[startNodeID + i]));
                    sub1Nodes.Add(GetNodeUnderNode(model, groundNodes[i]));
                    sub2Nodes.Add(GetNodeUnderNode(model, sub1Nodes[i]));
                }

                if (hasPiles)
                {
                    // Create sub2 piles
                    for (int i = 0; i < nodesPerFloor; i++)
                    {
                        Node[] sub1AdjacentNodes = GetAdjacentNodes(model, sub1Nodes[i]);
                        Node[] sub2AdjacentNodes = GetAdjacentNodes(model, sub2Nodes[i]);
                        e = new Element()
                        {
                            ID = elementID, ElementType = new Beam3D(material, sub2AdjacentNodes, sub1AdjacentNodes)
                            {
                                Density          = 7.85,
                                SectionArea      = b * h,
                                MomentOfInertiaY = b * b * b * h,
                                MomentOfInertiaZ = b * h * h * h,
                            }
                        };
                        e.NodesDictionary.Add(sub2Nodes[i].ID, sub2Nodes[i]);
                        e.NodesDictionary.Add(sub1Nodes[i].ID, sub1Nodes[i]);
                        foreach (Node node in sub2AdjacentNodes)
                        {
                            e.NodesDictionary.Add(node.ID, node);
                        }
                        foreach (Node node in sub1AdjacentNodes)
                        {
                            e.NodesDictionary.Add(node.ID, node);
                        }
                        model.ElementsDictionary.Add(e.ID, e);
                        model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                        elementID++;
                    }
                    // Create sub1 piles
                    for (int i = 0; i < nodesPerFloor; i++)
                    {
                        Node[] sub1AdjacentNodes   = GetAdjacentNodes(model, sub1Nodes[i]);
                        Node[] groundAdjacentNodes = GetAdjacentNodes(model, groundNodes[i]);
                        e = new Element()
                        {
                            ID          = elementID,
                            ElementType = new Beam3D(material, sub1AdjacentNodes, groundAdjacentNodes)
                            {
                                Density          = 7.85,
                                SectionArea      = b * h,
                                MomentOfInertiaY = b * b * b * h,
                                MomentOfInertiaZ = b * h * h * h,
                            }
                        };
                        e.NodesDictionary.Add(sub1Nodes[i].ID, sub1Nodes[i]);
                        e.NodesDictionary.Add(groundNodes[i].ID, groundNodes[i]);
                        foreach (Node node in sub1AdjacentNodes)
                        {
                            e.NodesDictionary.Add(node.ID, node);
                        }
                        foreach (Node node in groundAdjacentNodes)
                        {
                            e.NodesDictionary.Add(node.ID, node);
                        }
                        model.ElementsDictionary.Add(e.ID, e);
                        model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                        elementID++;
                    }
                }
            }
            else
            {
                for (int i = 0; i < nodesPerFloor; i++)
                {
                    groundNodes.Add(model.NodesDictionary[startNodeID + i]);
                }
                startNodeID += nodesPerFloor;
            }

            // Create ground-to-1st-floor beams
            for (int i = 0; i < nodesPerFloor; i++)
            {
                Node[] groundAdjacentNodes = GetAdjacentNodes(model, groundNodes[i]);
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, isInHexaSoil ? groundAdjacentNodes : null, null)
                    {
                        Density          = 7.85,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(groundNodes[i].ID, groundNodes[i]);
                e.NodesDictionary.Add(startNodeID + i, model.NodesDictionary[startNodeID + i]);
                if (isInHexaSoil)
                {
                    foreach (Node node in groundAdjacentNodes)
                    {
                        e.NodesDictionary.Add(node.ID, node);
                    }
                }
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
            }

            for (int i = 0; i < floors; i++)
            {
                double dens = i == floors - 1 ? 10 : 7.85;
                // Horizontal elements
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 4; k++)
                    {
                        e = new Element()
                        {
                            ID          = elementID,
                            ElementType = new Beam3D(material, null, null)
                            {
                                Density          = dens,
                                SectionArea      = b * h,
                                MomentOfInertiaY = b * b * b * h,
                                MomentOfInertiaZ = b * h * h * h,
                            }
                        };
                        e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + j * 5 + k, model.NodesDictionary[startNodeID + i * nodesPerFloor + j * 5 + k]);
                        e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + j * 5 + k + 1, model.NodesDictionary[startNodeID + i * nodesPerFloor + j * 5 + k + 1]);
                        model.ElementsDictionary.Add(e.ID, e);
                        model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                        elementID++;
                    }
                }
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, null, null)
                    {
                        Density          = dens,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 3 * 5, model.NodesDictionary[startNodeID + i * nodesPerFloor + 3 * 5]);
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 3 * 5 + 1, model.NodesDictionary[startNodeID + i * nodesPerFloor + 3 * 5 + 1]);
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, null, null)
                    {
                        Density          = dens,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 3 * 5 + 1, model.NodesDictionary[startNodeID + i * nodesPerFloor + 3 * 5 + 1]);
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 3 * 5 + 2, model.NodesDictionary[startNodeID + i * nodesPerFloor + 3 * 5 + 2]);
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
                // Vertical elements
                for (int j = 0; j < 5; j++)
                {
                    for (int k = 0; k < 2; k++)
                    {
                        e = new Element()
                        {
                            ID          = elementID,
                            ElementType = new Beam3D(material, null, null)
                            {
                                Density          = dens,
                                SectionArea      = b * h,
                                MomentOfInertiaY = b * b * b * h,
                                MomentOfInertiaZ = b * h * h * h,
                            }
                        };
                        e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + k * 5 + j, model.NodesDictionary[startNodeID + i * nodesPerFloor + k * 5 + j]);
                        e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + (k + 1) * 5 + j, model.NodesDictionary[startNodeID + i * nodesPerFloor + (k + 1) * 5 + j]);
                        model.ElementsDictionary.Add(e.ID, e);
                        model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                        elementID++;
                    }
                }
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, null, null)
                    {
                        Density          = dens,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 2, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 2]);
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 5, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 5]);
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, null, null)
                    {
                        Density          = dens,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 3, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 3]);
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 6, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 6]);
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
                e = new Element()
                {
                    ID          = elementID,
                    ElementType = new Beam3D(material, null, null)
                    {
                        Density          = dens,
                        SectionArea      = b * h,
                        MomentOfInertiaY = b * b * b * h,
                        MomentOfInertiaZ = b * h * h * h,
                    }
                };
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 4, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 4]);
                e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + 2 * 5 + 7, model.NodesDictionary[startNodeID + i * nodesPerFloor + 2 * 5 + 7]);
                model.ElementsDictionary.Add(e.ID, e);
                model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                elementID++;
                // Floor-to-floor beams
                if (i == floors - 1)
                {
                    continue;
                }
                for (int j = 0; j < nodesPerFloor; j++)
                {
                    e = new Element()
                    {
                        ID          = elementID,
                        ElementType = new Beam3D(material, null, null)
                        {
                            Density          = dens,
                            SectionArea      = b * h,
                            MomentOfInertiaY = b * b * b * h,
                            MomentOfInertiaZ = b * h * h * h,
                        }
                    };
                    e.NodesDictionary.Add(startNodeID + i * nodesPerFloor + j, model.NodesDictionary[startNodeID + i * nodesPerFloor + j]);
                    e.NodesDictionary.Add(startNodeID + (i + 1) * nodesPerFloor + j, model.NodesDictionary[startNodeID + (i + 1) * nodesPerFloor + j]);
                    model.ElementsDictionary.Add(e.ID, e);
                    model.SubdomainsDictionary[subdomainID].ElementsDictionary.Add(e.ID, e);
                    elementID++;
                }
            }
        }