private Vector CreateInterfaceProblemRhs(FetiDPFlexibilityMatrix flexibility, IFetiDPCoarseProblemSolver coarseProblemSolver, Vector globalFcStar, Vector dr) { // rhs = dr - FIrc * inv(KccStar) * fcStar Vector rhs = coarseProblemSolver.MultiplyInverseCoarseProblemMatrixTimes(globalFcStar); rhs = flexibility.MultiplyFIrc(rhs); rhs = dr - rhs; return(rhs); }
public static void TestInterfaceProblemCreation() { // 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); model.ConnectDataStructures(); solver.OrderDofs(false); solver.Initialize(); // Mock the stiffness matrices and force vectors Dictionary <int, IFetiDPSubdomainMatrixManager> matrixManagers = MockStiffnesses(); Vector dr = VectorDr; // Access private fields of FetiDPSolver FieldInfo fi = typeof(FetiDPSolver).GetField("lagrangeEnumerator", BindingFlags.NonPublic | BindingFlags.Instance); var lagrangeEnumerator = (FetiDPLagrangeMultipliersEnumerator)fi.GetValue(solver); fi = typeof(FetiDPSolver).GetField("dofSeparator", BindingFlags.NonPublic | BindingFlags.Instance); var dofSeparator = (FetiDPDofSeparator)fi.GetValue(solver); // Hardcoded coarse problem matrix and rhs var coarseSolver = new DenseFetiDPCoarseProblemSolver(model.Subdomains); Vector globalFcStar = VectorFcStar; Matrix inverseKccStar = MatrixKccStar.Invert(); // It must be set as a private field using reflection. fi = typeof(DenseFetiDPCoarseProblemSolver).GetField("inverseGlobalKccStar", BindingFlags.NonPublic | BindingFlags.Instance); fi.SetValue(coarseSolver, inverseKccStar); // Create the rhs vector of the interface problem FetiDPInterfaceProblemSolver interfaceSolver = new FetiDPInterfaceProblemSolver.Builder().Build(); var flexibility = new FetiDPFlexibilityMatrix(dofSeparator, lagrangeEnumerator, matrixManagers); Vector fcStar = VectorFcStar; MethodInfo method = interfaceSolver.GetType().GetMethod("CreateInterfaceProblemRhs", BindingFlags.NonPublic | BindingFlags.Instance); // reflection for the private method Vector interfaceRhs = (Vector)method.Invoke(interfaceSolver, new object[] { flexibility, coarseSolver, fcStar, dr }); // Create the matrix of the interface problem by multiplying with identity matrix int numLagranges = lagrangeEnumerator.NumLagrangeMultipliers; var interfaceMatrixImplicit = new FetiDPInterfaceProblemSolver.InterfaceProblemMatrix(flexibility, coarseSolver); Matrix interfaceMatrix = MultiplyWithIdentity(numLagranges, numLagranges, interfaceMatrixImplicit.Multiply); // Action<T> is contravariant!!! // Check against expected linear system double tol = 1E-13; Assert.True(InterfaceProblemVector.Equals(interfaceRhs, tol)); Assert.True(InterfaceProblemMatrix.Equals(interfaceMatrix, tol)); }
public static void TestFlexibilityMatrices() { // 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); model.ConnectDataStructures(); solver.OrderDofs(false); solver.Initialize(); // Mock the stiffness matrices Dictionary <int, IFetiDPSubdomainMatrixManager> matrixManagers = MockStiffnesses(); // Access private fields of FetiDPSolver FieldInfo fi = typeof(FetiDPSolver).GetField("lagrangeEnumerator", BindingFlags.NonPublic | BindingFlags.Instance); var lagrangeEnumerator = (FetiDPLagrangeMultipliersEnumerator)fi.GetValue(solver); fi = typeof(FetiDPSolver).GetField("dofSeparator", BindingFlags.NonPublic | BindingFlags.Instance); var dofSeparator = (FetiDPDofSeparator)fi.GetValue(solver); // Create the flexibility matrices by multiplying with identity matrices int numLagranges = lagrangeEnumerator.NumLagrangeMultipliers; int numCornerDofs = dofSeparator.NumGlobalCornerDofs; var flexibility = new FetiDPFlexibilityMatrix(dofSeparator, lagrangeEnumerator, matrixManagers); Matrix FIrr = MultiplyWithIdentity(numLagranges, numLagranges, flexibility.MultiplyFIrr); Matrix FIrc = MultiplyWithIdentity(numLagranges, numLagranges, (x, y) => y.CopyFrom(flexibility.MultiplyFIrc(x))); // Check against expected matrices double tol = 1E-11; Assert.True(MatrixFIrr.Equals(FIrr, tol)); Assert.True(MatrixFIrc.Equals(FIrc, tol)); }
public static void TestInterfaceProblemSolution() { // 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); model.ConnectDataStructures(); solver.OrderDofs(false); solver.Initialize(); // Mock the stiffness matrices and force vectors Dictionary <int, IFetiDPSubdomainMatrixManager> matrixManagers = MockStiffnesses(); Dictionary <int, IFetiSubdomainMatrixManager> matrixManagersPreconditioning = MockStiffnessesForPreconditioning(); Dictionary <int, Matrix> Krr = MatricesKrr; Vector dr = VectorDr; // Access private fields of FetiDPSolver FieldInfo fi = typeof(FetiDPSolver).GetField("lagrangeEnumerator", BindingFlags.NonPublic | BindingFlags.Instance); var lagrangeEnumerator = (FetiDPLagrangeMultipliersEnumerator)fi.GetValue(solver); fi = typeof(FetiDPSolver).GetField("dofSeparator", BindingFlags.NonPublic | BindingFlags.Instance); var dofSeparator = (FetiDPDofSeparator)fi.GetValue(solver); // Hardcoded coarse problem matrix and rhs var coarseSolver = new DenseFetiDPCoarseProblemSolver(model.Subdomains); Vector globalFcStar = VectorFcStar; Matrix inverseKccStar = MatrixKccStar.Invert(); // It must be set as a private field using reflection. fi = typeof(DenseFetiDPCoarseProblemSolver).GetField("inverseGlobalKccStar", BindingFlags.NonPublic | BindingFlags.Instance); fi.SetValue(coarseSolver, inverseKccStar); // Dirichlet preconditioner var precondFactory = new DirichletPreconditioner.Factory(); var repackagedKrr = new Dictionary <int, IMatrixView>(); foreach (var idMatrixPair in Krr) { repackagedKrr[idMatrixPair.Key] = idMatrixPair.Value; } var stiffnessDistribution = new HomogeneousStiffnessDistribution(model, dofSeparator); stiffnessDistribution.Update(null); IFetiPreconditioner preconditioner = precondFactory.CreatePreconditioner(model, stiffnessDistribution, dofSeparator, lagrangeEnumerator, matrixManagersPreconditioning); // Solve the interface problem FetiDPInterfaceProblemSolver interfaceSolver = new FetiDPInterfaceProblemSolver.Builder().Build(); var flexibility = new FetiDPFlexibilityMatrix(dofSeparator, lagrangeEnumerator, matrixManagers); var logger = new SolverLogger("mock FETI-DP"); (Vector lagranges, Vector uc) = interfaceSolver.SolveInterfaceProblem( flexibility, preconditioner, coarseSolver, globalFcStar, dr, GlobalForcesNorm, logger); // Check against expected solution double tol = 1E-7; Assert.True(SolutionLagrangeMultipliers.Equals(lagranges, tol)); Assert.True(SolutionCornerDisplacements.Equals(uc, tol)); }
public (Vector lagrangeMultipliers, Vector cornerDisplacements) SolveInterfaceProblem(FetiDPFlexibilityMatrix flexibility, IFetiPreconditioner preconditioner, IFetiDPCoarseProblemSolver coarseProblemSolver, Vector globalFcStar, Vector dr, double globalForcesNorm, SolverLogger logger) { int systemOrder = flexibility.Order; // Matrix, preconditioner & rhs var pcgMatrix = new InterfaceProblemMatrix(flexibility, coarseProblemSolver); var pcgPreconditioner = new InterfaceProblemPreconditioner(preconditioner); Vector pcgRhs = CreateInterfaceProblemRhs(flexibility, coarseProblemSolver, globalFcStar, dr); // Solve the interface problem using PCG algorithm var pcgBuilder = new PcgAlgorithm.Builder(); pcgBuilder.MaxIterationsProvider = maxIterationsProvider; pcgBuilder.ResidualTolerance = pcgConvergenceTolerance; pcgBuilder.Convergence = pcgConvergenceStrategyFactory.CreateConvergenceStrategy(globalForcesNorm); PcgAlgorithm pcg = pcgBuilder.Build(); //TODO: perhaps use the pcg from the previous analysis if it has reorthogonalization. var lagranges = Vector.CreateZero(systemOrder); IterativeStatistics stats = pcg.Solve(pcgMatrix, pcgPreconditioner, pcgRhs, lagranges, true, () => Vector.CreateZero(systemOrder)); // Log statistics about PCG execution if (!stats.HasConverged) { throw new IterativeSolverNotConvergedException(FetiDPSolver.name + " did not converge to a solution. PCG" + $" algorithm run for {stats.NumIterationsRequired} iterations and the residual norm ratio was" + $" {stats.ResidualNormRatioEstimation}"); } logger.LogIterativeAlgorithm(stats.NumIterationsRequired, stats.ResidualNormRatioEstimation); // Calculate corner displacements: uc = inv(KccStar) * (fcStar + FIrc^T * lagranges) Vector uc = flexibility.MultiplyTransposedFIrc(lagranges); uc.AddIntoThis(globalFcStar); uc = coarseProblemSolver.MultiplyInverseCoarseProblemMatrixTimes(uc); return(lagranges, uc); }
internal InterfaceProblemMatrix(FetiDPFlexibilityMatrix flexibility, IFetiDPCoarseProblemSolver coarseProblemSolver) { this.flexibility = flexibility; this.coarseProblemSolver = coarseProblemSolver; }