private static IVectorView SolveModel(Model model, IModelReader modelReader) { var builder = new SkylineSolver.Builder(); //builder.IsMatrixPositiveDefinite = false; var solver = builder.BuildSolver(model); const double timestep = 1; const double time = 100; var provider = new ProblemStructural(model, solver); var increments = 2; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments); childAnalyzerBuilder.ResidualTolerance = 1E-6; childAnalyzerBuilder.MaxIterationsPerIncrement = 50; childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); //var parentAnalyzerBuilder = new NewmarkDynamicAnalyzer.Builder(model, solver, provider, childAnalyzer, timestep, time); //parentAnalyzerBuilder.SetNewmarkParametersForConstantAcceleration(); //NewmarkDynamicAnalyzer parentAnalyzer = parentAnalyzerBuilder.Build(); var parentAnalyzer = new NewmarkDynamicAnalyzer(UpdateNewmarkModel, model, solver, provider, childAnalyzer, timestep, time, .25, .5); parentAnalyzer.Initialize(); for (int i = 0; i < time / timestep; i++) { //lambdag = .01 * i + 1; parentAnalyzer.SolveTimestep(i); } return(solver.LinearSystems[subdomainID].Solution); }
private static void SolveLinearStatic(Model model) { // Choose linear equation system solver var solverBuilder = new SkylineSolver.Builder(); ISolver 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 parentAnalyzer.Initialize(); parentAnalyzer.Solve(); // Logging displacement, strain, and stress fields. string outputDirectory = workingDirectory + "\\Plots"; childAnalyzer.LogFactories[0] = new VtkLogFactory(model, outputDirectory) { LogDisplacements = true, LogStrains = true, LogStresses = true, VonMisesStressCalculator = new PlaneStressVonMises() }; // Run the analysis parentAnalyzer.BuildMatrices(); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); }
private static void SolveBuildingInNoSoilSmall() { VectorExtensions.AssignTotalAffinityCount(); Model model = new Model(); model.SubdomainsDictionary.Add(1, new Subdomain() { ID = 1 }); BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1, model.ElementsDictionary.Count + 1, 1, 4, false, false); model.Loads.Add(new Load() { Amount = -100, Node = model.Nodes[21], DOF = DOFType.X }); model.ConnectDataStructures(); SolverSkyline solver = new SolverSkyline(model); ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary); LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary); StaticAnalyzer parentAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary); analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 }); parentAnalyzer.BuildMatrices(); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); }
private static IVectorView[] SolveModelsWithNewmark(Model[] models, IModelReader[] modelReaders) { Vector[] initialValues = new Vector[models.Length]; var value0 = new Dictionary <int, double[]>(); for (int i = 0; i < models.Length; i++) { double[] v0 = new double[models[i].Nodes.Count]; value0.Add(i, v0); } foreach (Node node in models[0].Nodes) { value0[0][node.ID] = 1; } DenseMatrixSolver[] solvers = new DenseMatrixSolver[models.Length]; IConvectionDiffusionIntegrationProvider[] providers = new IConvectionDiffusionIntegrationProvider[models.Length]; IChildAnalyzer[] childAnalyzers = new IChildAnalyzer[models.Length]; for (int i = 0; i < models.Length; i++) { initialValues[i] = Vector.CreateFromArray(value0[i]); //var builder = new DenseMatrixSolver.Builder(); builder.IsMatrixPositiveDefinite = false; solvers[i] = builder.BuildSolver(models[i]); providers[i] = new ProblemConvectionDiffusion2(models[i], solvers[i]); childAnalyzers[i] = new LinearAnalyzer(models[i], solvers[i], providers[i]); } const double timestep = .1; const double time = 3; var parentAnalyzer = new ConvectionDiffusionImplicitDynamicAnalyzerMultiModel(UpdateModels, models, solvers, providers, childAnalyzers, timestep, time, initialTemperature: initialValues); parentAnalyzer.Initialize(); var structuralModel = CreateStructuralModel(3e4, 0, new DynamicMaterial(.001, 0, 0, true), 0, new double[] { 1000, 0, 0 }, 1).Item1; // new Model(); var structuralSolver = structuralBuilder.BuildSolver(structuralModel); var structuralProvider = new ProblemStructural(structuralModel, structuralSolver); //var structuralChildAnalyzer = new LinearAnalyzer(structuralModel, structuralSolver, structuralProvider); var increments = 2; var structuralChildAnalyzerBuilder = new LoadControlAnalyzer.Builder(structuralModel, structuralSolver, structuralProvider, increments); structuralChildAnalyzerBuilder.ResidualTolerance = 1E-6; structuralChildAnalyzerBuilder.MaxIterationsPerIncrement = 50; structuralChildAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default LoadControlAnalyzer structuralChildAnalyzer = structuralChildAnalyzerBuilder.Build(); var structuralParentAnalyzer = new NewmarkDynamicAnalyzer(UpdateNewmarkModel, structuralModel, structuralSolver, structuralProvider, structuralChildAnalyzer, timestep, time, 0.25, .5); structuralParentAnalyzer.Initialize(); for (int i = 0; i < time / timestep; i++) { parentAnalyzer.SolveTimestep(i); structuralParentAnalyzer.SolveTimestep(i); } return(solvers.Select(x => x.LinearSystems[subdomainID].Solution).ToArray()); }
public static void SuiteSparseMemoryConsumptionDebugging() { for (int rep = 0; rep < 10; ++rep) { var benchmarkBuilder = new CantileverBeam.Builder(); //benchmarkBuilder.Length = 5.0; CantileverBeam benchmark = benchmarkBuilder.BuildWithQuad4Elements(2000, 100); // Solver var solverBuilder = new SuiteSparseSolver.Builder(); using (SuiteSparseSolver solver = solverBuilder.BuildSolver(benchmark.Model)) { // Structural problem provider var provider = new ProblemStructural(benchmark.Model, solver); // Linear static analysis var childAnalyzer = new LinearAnalyzer(benchmark.Model, solver, provider); var parentAnalyzer = new StaticAnalyzer(benchmark.Model, solver, provider, childAnalyzer); // Run the analysis parentAnalyzer.Initialize(); parentAnalyzer.Solve(); } } }
public static void CheckSubmatrices() { double tolerance = 1E-10; Model model = CreateModel(); int id = model.Subdomains.First().ID; var solver = (new SkylineSolver.Builder()).BuildSolver(model); var problem = new ProblemStructural(model, solver); // Prepare model model.ConnectDataStructures(); // Order dofs and initialize linear system solver.OrderDofs(true); ILinearSystem linearSystem = solver.LinearSystems.First().Value; linearSystem.Reset(); // Necessary to define the linear system's size // Build and assign global matrices (IMatrixView Kff, IMatrixView Kfc, IMatrixView Kcf, IMatrixView Kcc) = problem.CalculateSubMatrices(model.Subdomains.First()); // Checks Assert.True(expectedKff.Equals(Kff, tolerance)); Assert.True(expectedKcf.Transpose().Equals(Kfc, tolerance)); Assert.True(expectedKcf.Equals(Kcf, tolerance)); Assert.True(expectedKcc.Equals(Kcc, tolerance)); }
public static void CheckStaticCondensation() { double tolerance = 1E-10; Model model = CreateModel(); int id = model.Subdomains.First().ID; var solver = (new SkylineSolver.Builder()).BuildSolver(model); var problem = new ProblemStructural(model, solver); // Prepare model model.ConnectDataStructures(); // Order dofs and initialize linear system solver.OrderDofs(true); ILinearSystem linearSystem = solver.LinearSystems.First().Value; linearSystem.Reset(); // Necessary to define the linear system's size // Build and assign global matrices (IMatrixView Kff, IMatrixView Kfc, IMatrixView Kcf, IMatrixView Kcc) = problem.CalculateSubMatrices(model.Subdomains.First()); linearSystem.Matrix = Kff; // Static condensation: Kcondensed = Kcc - Kcf * inv(Kff) * Kfc Dictionary <int, Matrix> invKffTimesKfc = solver.InverseSystemMatrixTimesOtherMatrix( new Dictionary <int, IMatrixView>() { { id, Kfc } }); IMatrixView condensedK = Kcc.Subtract(Kcf.MultiplyRight(invKffTimesKfc[id])); // Checks Assert.True(expectedCondensedK.Equals(condensedK, tolerance)); }
private static void SolveBuildingInNoSoilSmallVRFStochastic() { VectorExtensions.AssignTotalAffinityCount(); Model model = new Model(); model.SubdomainsDictionary.Add(1, new Subdomain() { ID = 1 }); BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1, model.ElementsDictionary.Count + 1, 1, 4, false, false); model.Loads.Add(new Load() { Amount = -100, Node = model.Nodes[21], DOF = DOFType.X }); model.ConnectDataStructures(); PowerSpectrumTargetEvaluatorCoefficientsProvider stochasticProvider = new PowerSpectrumTargetEvaluatorCoefficientsProvider(10, 0.1, 1.2, 20, 200, DOFType.X, 0.1, 200, 1e-10); SolverSkyline solver = new SolverSkyline(model); ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary); LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary); StaticAnalyzer childAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary); VRFMonteCarloAnalyzerWithStochasticMaterial stochasticAnalyzer = new VRFMonteCarloAnalyzerWithStochasticMaterial(model, provider, childAnalyzer, solver.SubdomainsDictionary, stochasticProvider, stochasticProvider, 1, 20, "monteCarlo"); analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 }); //stochasticAnalyzer.BuildMatrices(); //childAnalyzer.Initialize(); stochasticAnalyzer.Solve(); }
/// <summary> /// Creates an instance that uses a specific problem type and an appropriate child analyzer for the construction of the system of equations arising from the actual physical problem /// </summary> /// <param name="provider">Instance of the problem type to be solver</param> /// <param name="childAnalyzer">Instance of the child analyzer that will handle the solution of the system of equations</param> /// <param name="linearSystem">Instance of the linear system that will be initialized</param> public StaticAnalyzer(ProblemStructural provider, LinearAnalyzer childAnalyzer, SkylineLinearSystem linearSystem) { this.provider = provider; this.ChildAnalyzer = childAnalyzer; this.ChildAnalyzer.ParentAnalyzer = this; this.linearSystem = linearSystem; }
public static void TestSolver() { // Setup the model and solver Model model = Quads4x4MappingMatricesTests.CreateModel(); Dictionary <int, HashSet <INode> > cornerNodes = Quads4x4MappingMatricesTests.DefineCornerNodes(model); var fetiMatrices = new DenseFetiDPSubdomainMatrixManager.Factory(); var cornerNodeSelection = new UsedDefinedCornerNodes(cornerNodes); var solver = new FetiDPSolver.Builder(cornerNodeSelection, fetiMatrices).BuildSolver(model); var problem = new ProblemStructural(model, solver); var linearAnalyzer = new LinearAnalyzer(model, solver, problem); var staticAnalyzer = new StaticAnalyzer(model, solver, problem, linearAnalyzer); // Run the analysis staticAnalyzer.Initialize(); staticAnalyzer.Solve(); // Gather the global displacements var sudomainDisplacements = new Dictionary <int, IVectorView>(); foreach (var ls in solver.LinearSystems) { sudomainDisplacements[ls.Key] = ls.Value.Solution; } Vector globalU = solver.GatherGlobalDisplacements(sudomainDisplacements); // Check against expected solution double tol = 1E-7; Assert.True(SolutionGlobalDisplacements.Equals(globalU, tol)); }
public void TestEulerBeam2DLinearBendingExample() { // Model and node creation var model = new Model(); model.NodesDictionary.Add(1, new Node { ID = 1, X = 0.0, Y = 0.0, Z = 0.0 }); model.NodesDictionary.Add(2, new Node { ID = 2, X = 100.0, Y = 0.0, Z = 0.0 }); model.NodesDictionary.Add(3, new Node { ID = 3, X = 200.0, Y = 0.0, Z = 0.0 }); // Constrain bottom node and add nodal load value model.NodesDictionary[1].Constraints.AddRange(new[] { DOFType.X, DOFType.Y, DOFType.Z, DOFType.RotZ }); model.Loads.Add(new Load() { Amount = 2000, Node = model.NodesDictionary[3], DOF = DOFType.Y }); // Generate elements of the structure for (int iElem = 0; iElem < 2; iElem++) { // Create new Beam2D section and element var element = new EulerBeam2D(2.1e4) { ID = iElem + 1, Density = 7.85, SectionArea = 91.04, MomentOfInertia = 8091.00 }; element.ElementType = element; // Add nodes to the created element element.AddNode(model.NodesDictionary[iElem + 1]); element.AddNode(model.NodesDictionary[iElem + 2]); // Add Hexa element to the element and subdomains dictionary of the model model.ElementsDictionary.Add(element.ID, element); } // Needed in order to make all the required data structures model.ConnectDataStructures(); // Setup var linearSystem = new SkylineLinearSystem(model.Forces); var solver = new SolverSkyline(linearSystem); var provider = new ProblemStructural(model); var childAnalyzer = new LinearAnalyzer(solver); var parentAnalyzer = new StaticAnalyzer(provider, childAnalyzer, linearSystem); parentAnalyzer.BuildMatrices(); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); // Tests if calculated solution meets expected var expectedSolution = new double[] { 0, 9.80905689841542, 0.17656302417147754, 0, 31.388982074929341, 0.23541736556197002 }; for (int i = 0; i < expectedSolution.Length; i++) { Assert.Equal(expectedSolution[i], linearSystem.Solution[i], 12); } }
public void SolveNLBeam() { var m = new Model(); m.NodesDictionary.Add(1, new Node(id: 1, x: 0, y: 0, z: 0)); m.NodesDictionary.Add(2, new Node(id: 2, x: 5, y: 0, z: 0)); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.TranslationX }); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.TranslationY }); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.TranslationZ }); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.RotationX }); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.RotationY }); m.NodesDictionary[1].Constraints.Add(new Constraint { DOF = StructuralDof.RotationZ }); m.ElementsDictionary.Add(1, new Element() { ID = 1, ElementType = new Beam3DCorotationalQuaternion(m.Nodes, new ElasticMaterial3D() { YoungModulus = 2.1e6, PoissonRatio = 0.2 }, 1, new BeamSection3D(0.06, 0.0002, 0.00045, 0.000818, 0.05, 0.05)) }); m.ElementsDictionary[1].AddNodes(m.Nodes); m.SubdomainsDictionary.Add(1, new Subdomain(1)); m.SubdomainsDictionary[1].Elements.Add(m.ElementsDictionary[1]); m.Loads.Add(new Load() { Node = m.NodesDictionary[2], Amount = 100, DOF = StructuralDof.TranslationY }); // Solver var solverBuilder = new SkylineSolver.Builder(); ISolver solver = solverBuilder.BuildSolver(m); // Problem type var provider = new ProblemStructural(m, solver); // Analyzers int increments = 10; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(m, solver, provider, increments); //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); var parentAnalyzer = new StaticAnalyzer(m, solver, provider, childAnalyzer); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); }
public void ContinuumElement3DNonLinearVonMisesMaterialDynamicConsistent() { IList <Node> nodes = new List <Node>(); // Create Model var model = new Model(); // Create Subdomain model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); // Create von Mises Plastic Material var solidMaterial = new VonMisesMaterial3D(youngModulus, poissonRatio, yieldStress, plasticModulus); // Create Dynamic Material var dynamicMaterial = new DynamicMaterial(density, 0, 0, true); 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 = 1.93737; Assert.Equal(expectedValue, computedValue, 2); }
public void TestSolveHexaCantileverBeam() { var model = new Model(); model.SubdomainsDictionary.Add(1, new Subdomain(1)); HexaSimpleCantileverBeam.MakeCantileverBeam(model, 0, 0, 0, model.NodesDictionary.Count + 1, model.ElementsDictionary.Count + 1, 1); model.Loads.Add(new Load() { Amount = -0.25, Node = model.Nodes[16], DOF = StructuralDof.TranslationZ }); model.Loads.Add(new Load() { Amount = -0.25, Node = model.Nodes[17], DOF = StructuralDof.TranslationZ }); model.Loads.Add(new Load() { Amount = -0.25, Node = model.Nodes[18], DOF = StructuralDof.TranslationZ }); model.Loads.Add(new Load() { Amount = -0.25, Node = model.Nodes[19], DOF = StructuralDof.TranslationZ }); var solverBuilder = new SkylineSolver.Builder(); ISolver solver = solverBuilder.BuildSolver(model); var provider = new ProblemStructural(model, solver); var childAnalyzer = new LinearAnalyzer(model, solver, provider); var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); //childAnalyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 47 }); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); double[] expectedDisplacements = new double[] { -0.0000025899520106, -0.0000004898560318, -0.0000031099520106, -0.0000025899520106, 0.0000004898560318, -0.0000031099520106, 0.0000025899520106, 0.0000004898560318, -0.0000031099520106, 0.0000025899520106, -0.0000004898560318, -0.0000031099520106, -0.0000045673419128, -0.0000002423136749, -0.0000107872459340, -0.0000045673419128, 0.0000002423136749, -0.0000107872459340, 0.0000045673419128, 0.0000002423136749, -0.0000107872459340, 0.0000045673419128, -0.0000002423136749, -0.0000107872459340, -0.0000057299058132, -0.0000001253780263, -0.0000216044936601, -0.0000057299058132, 0.0000001253780263, -0.0000216044936601, 0.0000057299058132, 0.0000001253780263, -0.0000216044936601, 0.0000057299058132, -0.0000001253780263, -0.0000216044936601, -0.0000061325564473, -0.0000000425738760, -0.0000339869559207, -0.0000061325564473, 0.0000000425738760, -0.0000339869559207, 0.0000061325564473, 0.0000000425738760, -0.0000339869559207, 0.0000061325564473, -0.0000000425738760, -0.0000339869559207 }; for (int i = 0; i < expectedDisplacements.Length; i++) { Assert.Equal(expectedDisplacements[i], solver.LinearSystems[1].Solution[i], 10); } }
public static void EmbeddedEBEinMatrix_NewtonRaphson() { // Model creation var model = new Model(); // Subdomains //model.SubdomainsDictionary.Add(subdomainID, new Subdomain() { ID = 1 }); model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); // Variables int monitorNode = 41; IDofType monitorDof = StructuralDof.TranslationZ; // Choose model EmbeddedEBEModelBuilder.EmbeddedExampleBuilder(model); //----------------------------------------------------------------------------------------------------------- // Model // Choose linear equation system solver //var solverBuilder = new SkylineSolver.Builder(); //SkylineSolver solver = solverBuilder.BuildSolver(model); var solverBuilder = new SuiteSparseSolver.Builder(); SuiteSparseSolver 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 int increments = 100; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments) { ResidualTolerance = 1E-03, MaxIterationsPerIncrement = 10 }; LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); // Choose parent analyzer -> Parent: Static var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); // Request output string outputFile = outputDirectory + "\\CNT-Embedded-3D_Results.txt"; var logger = new TotalLoadsDisplacementsPerIncrementLog(model.SubdomainsDictionary[subdomainID], increments, model.NodesDictionary[monitorNode], monitorDof, outputFile); childAnalyzer.IncrementalLogs.Add(subdomainID, logger); // Run the analysis parentAnalyzer.Initialize(); parentAnalyzer.Solve(); // Create Paraview File var paraview = new ParaviewEmbedded3D(model, solver.LinearSystems[0].Solution, "test"); paraview.CreateParaviewFile(); }
/// <summary>Evaluates the specified iteration.</summary> /// <param name="iteration">The iteration.</param> /// <returns></returns> public double[] Evaluate(int iteration) { var solver = new SkylineSolver.Builder().BuildSolver(currentModel); var provider = new ProblemStructural(currentModel, solver); var childAnalyzer = new LinearAnalyzer(currentModel, solver, provider); var parentAnalyzer = new StaticAnalyzer(currentModel, solver, provider, childAnalyzer); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); return(new[] { solver.LinearSystems[0].Solution[56], solver.LinearSystems[0].Solution[58] }); }
public static void TestSolver() { // Setup the model double stiffnessRatio = 1E-2; // Do not change this! The expected solution is taken for this value Model model = CreateModel(stiffnessRatio); Dictionary <int, HashSet <INode> > cornerNodes = Quads4x4MappingMatricesTests.DefineCornerNodes(model); // Setup solver var interfaceSolverBuilder = new FetiDPInterfaceProblemSolver.Builder(); interfaceSolverBuilder.PcgConvergenceTolerance = 1E-7; //var fetiMatrices = new SkylineFetiDPSubdomainMatrixManager.Factory(); var fetiMatrices = new DenseFetiDPSubdomainMatrixManager.Factory(); var cornerNodeSelection = new UsedDefinedCornerNodes(cornerNodes); var fetiSolverBuilder = new FetiDPSolver.Builder(cornerNodeSelection, fetiMatrices); fetiSolverBuilder.InterfaceProblemSolver = interfaceSolverBuilder.Build(); fetiSolverBuilder.ProblemIsHomogeneous = false; fetiSolverBuilder.PreconditionerFactory = new DirichletPreconditioner.Factory(); FetiDPSolver fetiSolver = fetiSolverBuilder.BuildSolver(model); // Run the analysis var problem = new ProblemStructural(model, fetiSolver); var linearAnalyzer = new LinearAnalyzer(model, fetiSolver, problem); var staticAnalyzer = new StaticAnalyzer(model, fetiSolver, problem, linearAnalyzer); staticAnalyzer.Initialize(); staticAnalyzer.Solve(); // Gather the global displacements var sudomainDisplacements = new Dictionary <int, IVectorView>(); foreach (var ls in fetiSolver.LinearSystems) { sudomainDisplacements[ls.Key] = ls.Value.Solution; } Vector globalU = fetiSolver.GatherGlobalDisplacements(sudomainDisplacements); // Check against expected solution double tol = 1E-7; var globalUExpected = Vector.CreateFromArray(new double[] { 17.623494584618864, 12.564560593215612, 31.832863897135404, 34.496634608059082, 40.255481382985629, 66.49190654178912, 42.572002358887204, 99.798764204232072, 4.267568672307144, 9.00506902466324, 9.100928263505315, 31.107370029452451, 12.1615036308774, 66.065492717632239, 11.510673148931499, 102.06649895017948, -3.0529124682202156, 9.24107474483673, -7.8531777412741217, 26.728892403726846, -16.890006178831449, 70.602493468916791, -21.80233265288679, 109.39882637058051, -4.7311061272016808, 10.030926199331375, -5.6722429958962142, 18.837815470700932, 146.94209278892487, 392.04674590737193, -35.619167413693908, 1407.200332011206, -9.9609496807814057, 10.46574373452243, -17.603838651152756, 20.760800663270086, -843.13592713307355, 371.10700308359418, -1666.2547486301742, 3714.1637893447919 }); Assert.True(globalUExpected.Equals(globalU, tol)); }
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); }
private static double[] SolveModel() { var model = new Model(); model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); BuildCantileverModel(model, 850); // Solver var solverBuilder = new SkylineSolver.Builder(); ISolver solver = solverBuilder.BuildSolver(model); // Problem type var provider = new ProblemStructural(model, solver); // Analyzers int increments = 2; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments); childAnalyzerBuilder.ResidualTolerance = 1E-8; childAnalyzerBuilder.MaxIterationsPerIncrement = 100; childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); // initialize the anlaysis parentAnalyzer.Initialize(); // Output int[] monitoredNodes = new int[] { 6, 8 }; int[] monitoredDofs = monitoredNodes.Select(x => model.GlobalDofOrdering.GlobalFreeDofs[model.NodesDictionary[x], StructuralDof.TranslationX]).ToArray(); var watchDofs = new Dictionary <int, int[]>(); watchDofs.Add(subdomainID, monitoredDofs); var log1 = new TotalDisplacementsPerIterationLog(watchDofs); childAnalyzer.TotalDisplacementsPerIterationLog = log1; //run the analysis and give output parentAnalyzer.Solve(); var solutionOfIters5And12 = new double[] { log1.GetTotalDisplacement(5, 0, 3), log1.GetTotalDisplacement(12, 0, 3), log1.GetTotalDisplacement(5, 0, 9), log1.GetTotalDisplacement(12, 0, 9) }; return(solutionOfIters5And12); }
//public string PlotDirectory { get { return lsmPlotDirectory; } } public void Analyze(ISolver solver) { var problem = new ProblemStructural(Model, solver); var analyzer = new QuasiStaticCrackPropagationAnalyzer(Model, solver, /*problem,*/ crack, fractureToughness, maxIterations); // Subdomain plots if (subdomainPlotDirectory != null) { if (solver is FetiDPSolver fetiDP) { analyzer.DDLogger = new DomainDecompositionLoggerFetiDP(fetiDP, subdomainPlotDirectory); } else { analyzer.DDLogger = new DomainDecompositionLogger(subdomainPlotDirectory); } } analyzer.Initialize(); analyzer.Analyze(); #region crack propagation output // Write crack path //Console.WriteLine("Crack path:"); //foreach (var point in crack.CrackPath) //{ // Console.WriteLine("{0} {1}", point.X, point.Y); //} //Console.WriteLine(); // Write growth angles, lengths and SIFs if necessary //if (writePropagation) //{ // using (var writer = new StreamWriter(propagationPath)) // { // PropagationLogger logger = crack.CrackTipPropagators[crack.CrackTips[0]].Logger; // int numIterations = logger.GrowthAngles.Count; // writer.WriteLine(numIterations); // for (int i = 0; i < numIterations; ++i) // { // writer.Write(logger.GrowthAngles[i]); // writer.Write(" " + logger.GrowthLengths[i]); // writer.Write(" " + logger.SIFsMode1[i]); // writer.Write(" " + logger.SIFsMode2[i]); // writer.WriteLine(); // } // } //} #endregion }
public void Initialize() { elementVolumes = CalcElementVolumes(); //TODO: does this work with embedding? What if someone else overwrites the element's property? for (int e = 0; e < NumElements; ++e) { elementTypes[e].DofEnumerator = penalizers[e]; } problem = new ProblemStructural(model, solver); linearAnalyzer = new LinearAnalyzer(model, solver, problem); staticAnalyzer = new StaticAnalyzer(model, solver, problem, linearAnalyzer); }
//checked: apotelesmata C:\Users\turbo-x\Desktop\notes_elegxoi\MSOLVE_output_2\APOTELESMATA_MS_hexa8_cantilever_nea\IntegrationElasticCantileverBenchmark RunExample //Origin opou htan checked branch example/ms_development_nl_elements_merge //modifications: egine v2 public static TotalDisplacementsPerIterationLog RunExample() { //VectorExtensions.AssignTotalAffinityCount(); Model model = new Model(); int subdomainID = 1; model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); HexaCantileverBuilder_copyMS_222(model, 0.00219881744271988174427); //model.ConnectDataStructures(); //var linearSystems = new Dictionary<int, ILinearSystem>(); //I think this should be done automatically //linearSystems[subdomainID] = new SkylineLinearSystem(subdomainID, model.Subdomains[0].Forces); // Solver var solverBuilder = new SkylineSolver.Builder(); ISolver solver = solverBuilder.BuildSolver(model); // Problem type var provider = new ProblemStructural(model, solver); //var solver = new SolverSkyline(linearSystems[subdomainID]); //var linearSystemsArray = new[] { linearSystems[subdomainID] }; //var subdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.Subdomains[0]) }; //var subdomainMappers = new[] { new SubdomainGlobalMapping(model.Subdomains[0]) }; var increments = 2; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(model, solver, provider, increments); childAnalyzerBuilder.MaxIterationsPerIncrement = 100; childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); var watchDofs = new Dictionary <int, int[]>(); watchDofs.Add(subdomainID, new int[5] { 0, 11, 23, 35, 47 }); var log1 = new TotalDisplacementsPerIterationLog(watchDofs); childAnalyzer.TotalDisplacementsPerIterationLog = log1; parentAnalyzer.Initialize(); parentAnalyzer.Solve(); return(log1); }
private static Vector RunAnalysis(Model model) { // Setup analysis var linearSystem = new SkylineLinearSystem(model.Forces); var solver = new SolverSkyline(linearSystem); var provider = new ProblemStructural(model); var childAnalyzer = new LinearAnalyzer(solver); var parentAnalyzer = new StaticAnalyzer(provider, childAnalyzer, linearSystem); parentAnalyzer.BuildMatrices(); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); return(linearSystem.Solution); }
/// <summary>Evaluates the specified iteration.</summary> /// <param name="iteration">The iteration.</param> /// <returns></returns> public double[] Evaluate(int iteration) { //TODO: Perhaps the analyzer, solver, etc should be reused throughout the MonteCarlo, to avoid recalculating // connectivity and indexing structures. var solver = new SkylineSolver.Builder().BuildSolver(currentModel); var provider = new ProblemStructural(currentModel, solver); var childAnalyzer = new LinearAnalyzer(currentModel, solver, provider); var parentAnalyzer = new StaticAnalyzer(currentModel, solver, provider, childAnalyzer); parentAnalyzer.Initialize(); parentAnalyzer.Solve(); //return new[] { linearSystems[0].RHS[0] }; return(new[] { solver.LinearSystems[0].Solution[56], solver.LinearSystems[0].Solution[58] }); }
public static void EmbeddedEBEinMatrix_DisplacementControl() { // Model creation var model = new Model(); // Subdomains //model.SubdomainsDictionary.Add(subdomainID, new Subdomain() { ID = 1 }); model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); // Variables int monitorNode = 161; IDofType monitorDof = StructuralDof.TranslationZ; // Choose model EmbeddedEBEModelBuilder.EmbeddedExampleBuilder(model); //----------------------------------------------------------------------------------------------------------- // Model // Choose linear equation system solver //var solverBuilder = new SkylineSolver.Builder(); //SkylineSolver solver = solverBuilder.BuildSolver(model); var solverBuilder = new SuiteSparseSolver.Builder(); SuiteSparseSolver solver = solverBuilder.BuildSolver(model); // Choose the provider of the problem -> here a structural problem var provider = new ProblemStructural(model, solver); // Choose child analyzer -> Child: DisplacementControl var subdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; int increments = 100; var childAnalyzerBuilder = new DisplacementControlAnalyzer.Builder(model, solver, provider, increments); DisplacementControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); // Choose parent analyzer -> Parent: Static var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); // Request output string outputFile = outputDirectory + "\\CNT-Embedded-3D_Results.txt"; var logger = new TotalLoadsDisplacementsPerIncrementLog(model.SubdomainsDictionary[subdomainID], increments, model.NodesDictionary[monitorNode], monitorDof, outputFile); childAnalyzer.IncrementalLogs.Add(subdomainID, logger); // Run the analysis parentAnalyzer.Initialize(); parentAnalyzer.Solve(); }
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace) { ReplaceLambdaGInModel(modelsToReplace[0], lgElement); solversToReplace[0] = structuralBuilder.BuildSolver(modelsToReplace[0]); providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]); //solversToReplace[0].HandleMatrixWillBeSet(); //childAnalyzersToReplace[0] = new LinearAnalyzer(modelsToReplace[0], solversToReplace[0], providersToReplace[0]); var increments = 2; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(modelsToReplace[0], solversToReplace[0], (INonLinearProvider)providersToReplace[0], increments); childAnalyzerBuilder.ResidualTolerance = 1E-6; childAnalyzerBuilder.MaxIterationsPerIncrement = 50; childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; childAnalyzersToReplace[0] = childAnalyzerBuilder.Build(); }
private static void UpdateModels(Dictionary <int, IVector>[] solutions, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace) { double[] sol0 = solutions[0][0].CopyToArray(); double[] sol1 = solutions[1][0].CopyToArray(); modelsToReplace[0] = CreateModel(21000, 91.04, 1000.0); modelsToReplace[1] = CreateModel(21000, 91.04, 1000.0); for (int i = 0; i < modelsToReplace.Length; i++) { //providersToReplace[i]. solversToReplace[i] = builder.BuildSolver(modelsToReplace[i]); providersToReplace[i] = new ProblemStructural((Model)modelsToReplace[i], solversToReplace[i]); childAnalyzersToReplace[i] = new LinearAnalyzer(modelsToReplace[i], solversToReplace[i], providersToReplace[i]); } }
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace) { double[] sol0 = Solutions[0][0].CopyToArray(); double[] sol1 = Solutions[1][0].CopyToArray(); var load = new double[] { sol1[39], sol1[39], sol1[39] }; IDynamicMaterial commonDynamicMaterialProperties = new DynamicMaterial(.001, 0, 0, true); Accelerations = accelerations; Velocities = velocities; Displacements = displacements; modelsToReplace[0] = CreateStructuralModel(10e4, 0, commonDynamicMaterialProperties, 0, load).Item1; solversToReplace[0] = builder.BuildSolver(modelsToReplace[0]); providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]); childAnalyzersToReplace[0] = new LinearAnalyzer(modelsToReplace[0], solversToReplace[0], providersToReplace[0]); }
private static void UpdateNewmarkModel(Dictionary <int, IVector> accelerations, Dictionary <int, IVector> velocities, Dictionary <int, IVector> displacements, IStructuralModel[] modelsToReplace, ISolver[] solversToReplace, IImplicitIntegrationProvider[] providersToReplace, IChildAnalyzer[] childAnalyzersToReplace) { //double[] disp = displacements[0].CopyToArray(); //Displacements = Vector.CreateFromArray(disp); IDynamicMaterial commonDynamicMaterialProperties = new DynamicMaterial(.001, 0, 0, true); //modelsToReplace[0] = CreateModel1(1, 1, new DynamicMaterial(.001, 0, 0, true), 0, new double[] { 0, 0, 200 }, lambdag).Item1; ReplaceLambdaGInModel(modelsToReplace[0], lambdag); solversToReplace[0] = builder.BuildSolver(modelsToReplace[0]); providersToReplace[0] = new ProblemStructural(modelsToReplace[0], solversToReplace[0]); var increments = 2; var childAnalyzerBuilder = new LoadControlAnalyzer.Builder(modelsToReplace[0], solversToReplace[0], (INonLinearProvider)providersToReplace[0], increments); childAnalyzersToReplace[0] = childAnalyzerBuilder.Build(); }
private static void SolveModel() { var model = new Model(); model.SubdomainsDictionary.Add(subdomainID, new Subdomain(subdomainID)); var load = 850; BuildCantileverModel(model, load); // 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-5; childAnalyzerBuilder.MaxIterationsPerIncrement = 100; childAnalyzerBuilder.NumIterationsForMatrixRebuild = 1; //childAnalyzerBuilder.SubdomainUpdaters = new[] { new NonLinearSubdomainUpdater(model.SubdomainsDictionary[subdomainID]) }; // This is the default LoadControlAnalyzer childAnalyzer = childAnalyzerBuilder.Build(); var parentAnalyzer = new StaticAnalyzer(model, solver, provider, childAnalyzer); // Setup displacements log var watchDof = new Dictionary <int, int[]>(); //watchDof.Add(subdomainID, new int[1] { 46 }); watchDof.Add(subdomainID, new int[1] { 94 }); var log1 = new IncrementalDisplacementsLog(watchDof); childAnalyzer.IncrementalDisplacementsLog = log1; // Run the analysis parentAnalyzer.Initialize(); parentAnalyzer.Solve(); // Write log data to file WriteDisplacementsToFile(log1, watchDof, load); }