public Result SolvePDE(int Lelement, int Helement, double eps, out int iterations) { Mesh.GenerateMesh(Model.Shape, Lelement, Helement); GetConstantMatrix(); previousRes = new Result(Mesh.Elements, null); U = new Vector(Mesh.Nodes.Count * 2); previousRes.U = U; iterations = 0; do { previousRes.U = U; GetStiffnessMatrix(); GetTotalVector(); AsumeBoundaryConditions(); U = StiffnessMatrix.LUalgorithm(TotalVector); if (iterations == 0) { LinearU = U; } iterations++; }while ((Vector.Norm(previousRes.U - U) > eps * Vector.Norm(U)) && (iterations < 20)); previousRes.U = U; return(previousRes); }
/// <summary> /// Calculates part of the problem for unknown displacements /// </summary> /// <returns>A vector of the displacements which were previously unknown, and have now been solved</returns> protected KeyedVector <NodalDegreeOfFreedom> CalculateUnknownDisplacements() { StiffnessMatrix knownForcesUnknownDisplacementStiffnesses = this.matrixBuilder.BuildKnownForcesUnknownDisplacementStiffnessMatrix(); // K11 //TODO calculating the determinant is computationally intensive. We should use another method of model verification to speed this up. double det = knownForcesUnknownDisplacementStiffnesses.Determinant(); Guard.AgainstInvalidState(() => { return(det.IsApproximatelyEqualTo(0.0)); }, "We are unable to solve this model as it is able to move as a rigid body without deforming in any way. Are you missing any constraints?\r\nMatrix of stiffnesses for known forces and unknown displacements:\r\n {0}", knownForcesUnknownDisplacementStiffnesses); KeyedVector <NodalDegreeOfFreedom> knownForces = this.model.KnownForceVector(); // Fk StiffnessMatrix knownForcesKnownDisplacementsStiffnesses = this.matrixBuilder.BuildKnownForcesKnownDisplacementStiffnessMatrix(); // K12 KeyedVector <NodalDegreeOfFreedom> knownDisplacements = this.model.KnownDisplacementVector(); // Uk // solve for unknown displacements // Uu = K11^-1 * (Fk + (K12 * Uk)) KeyedVector <NodalDegreeOfFreedom> forcesDueToExternallyAppliedDisplacements = knownForcesKnownDisplacementsStiffnesses.Multiply(knownDisplacements); // K12 * Uk KeyedVector <NodalDegreeOfFreedom> externallyAppliedForces = knownForces.Add(forcesDueToExternallyAppliedDisplacements); // Fk + (K12 * Uk) // K11^-1 * (Fk + (K12 * Uk)) KeyedVector <NodalDegreeOfFreedom> unknownDisplacements = this.Solve(knownForcesUnknownDisplacementStiffnesses, externallyAppliedForces); return(unknownDisplacements); }
protected override KeyedVector <NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector <NodalDegreeOfFreedom> forceVector) { KeyedSquareMatrix <NodalDegreeOfFreedom> inverse = stiffnessMatrix.Inverse(); KeyedVector <NodalDegreeOfFreedom> solution = inverse.Multiply(forceVector); return(solution); }
public override IEnumerable <INumericalResult> Solve(int resultsCount) { IEnumerable <INumericalResult> results = new List <INumericalResult>(); if (_mesh.IsMeshGenerated) { GetConstantMatrix(); indeciesToDelete = getIndeciesWithStaticBoundaryConditions(); Matrix stiffnessMatrix = GetStiffnessMatrix(); stiffnessMatrix = applyStaticBoundaryConditions(stiffnessMatrix, indeciesToDelete); Matrix massMatrix = GetMassMatrix(); massMatrix = applyStaticBoundaryConditions(massMatrix, indeciesToDelete); #if (ALL_LAMBDAS) Vector firstEigenVector = null; double[] lambdas = null; Vector[] eigenVectors = null; int iterations = 0; do { if (eigenVectors != null) { firstEigenVector = eigenVectors[0]; } else { firstEigenVector = new Vector(stiffnessMatrix.CountRows); } firstEigenVector = applyAmplitudeToVector(firstEigenVector); Matrix nonlinearMatrix = GetNonlinearMatrix(firstEigenVector); nonlinearMatrix = applyStaticBoundaryConditions(nonlinearMatrix, indeciesToDelete); Matrix k = stiffnessMatrix + nonlinearMatrix; lambdas = k.GetEigenvalueSPAlgorithm(massMatrix, out eigenVectors, _error, resultsCount); iterations++; }while ((Vector.Norm(eigenVectors[0] - firstEigenVector) > _error) && (iterations < _maxIterations)); results = generateVibrationResults(lambdas, eigenVectors); #else Vector eigenVector; double lambda = StiffnessMatrix.GetMaxEigenvalueSPAlgorithm(out eigenVector, _error); addStaticPoints(eigenVector); EigenValuesNumericalResult result = new EigenValuesNumericalResult(_mesh.Elements, eigenVector, Math.Sqrt(lambda / _model.Material.Rho)); results.Add(result); #endif } return(results); }
/// <summary> /// Calculates part of the stiffness equations for the unknown reactions. /// </summary> /// <param name="unknownDisplacements">A vector of the displacements which were previously unknown</param> /// <returns>A vector of the reactions which were previously unknown, and have now been solved</returns> protected KeyedVector <NodalDegreeOfFreedom> CalculateUnknownReactions(KeyedVector <NodalDegreeOfFreedom> unknownDisplacements) { Guard.AgainstNullArgument(unknownDisplacements, "unknownDisplacements"); // Fu = K21 * Uu + K22 * Uk StiffnessMatrix unknownForcesUnknownDisplacementStiffnesses = this.matrixBuilder.BuildUnknownForcesUnknownDisplacementStiffnessMatrix(); // K21 StiffnessMatrix unknownForcesKnownDisplacementsStiffnesses = this.matrixBuilder.BuildUnknownForcesKnownDisplacementStiffnessMatrix(); // K22 KeyedVector <NodalDegreeOfFreedom> knownDisplacements = this.model.KnownDisplacementVector(); // Uk KeyedVector <NodalDegreeOfFreedom> lhsStatement = unknownForcesUnknownDisplacementStiffnesses.Multiply(unknownDisplacements); // K21 * Uu KeyedVector <NodalDegreeOfFreedom> rhsStatement = unknownForcesKnownDisplacementsStiffnesses.Multiply(knownDisplacements); // K22 * Uk KeyedVector <NodalDegreeOfFreedom> unknownReactions = lhsStatement.Add(rhsStatement); return(unknownReactions); }
public void KnownForcesUnknownDisplacementsMatrixCanBeGenerated() { ExpectCallForUnconstrainedNodalDegreeOfFreedoms().Repeat.Twice(); ExpectCallForElementsDirectlyConnectingNode2(); Expect.Call(spring1Calculator.GetStiffnessInGlobalCoordinatesAt(node2, DegreeOfFreedom.X, node2, DegreeOfFreedom.X)) .Return(2); Expect.Call(spring2Calculator.GetStiffnessInGlobalCoordinatesAt(node2, DegreeOfFreedom.X, node2, DegreeOfFreedom.X)) .Return(3); mocks.ReplayAll(); StiffnessMatrix result = SUT.BuildKnownForcesUnknownDisplacementStiffnessMatrix(); mocks.VerifyAll(); Helpers.AssertMatrix(result, 1, 1, 5); }
public void SetUp() { var span = new Mock <ISpan>(); span.Setup(s => s.Section.Area).Returns(3); span.Setup(s => s.Material.YoungModulus).Returns(5); span.Setup(s => s.Section.MomentOfInteria).Returns(11); span.Setup(s => s.Length).Returns(7); span.Setup(s => s.LeftNode.HorizontalMovementNumber).Returns(0); span.Setup(s => s.LeftNode.VerticalMovementNumber).Returns(1); span.Setup(s => s.LeftNode.LeftRotationNumber).Returns(2); span.Setup(s => s.LeftNode.RightRotationNumber).Returns(3); span.Setup(s => s.RightNode.HorizontalMovementNumber).Returns(4); span.Setup(s => s.RightNode.VerticalMovementNumber).Returns(5); span.Setup(s => s.RightNode.LeftRotationNumber).Returns(6); span.Setup(s => s.RightNode.RightRotationNumber).Returns(7); _stiffnessMatrix = new StiffnessMatrix(span.Object); }
public Matrix <double> CreateGlobalStiffnessMatrix(int sizeOfMatrix, Material material, List <Element> elements) { Matrix <double> Ktot = Matrix <double> .Build.Dense(sizeOfMatrix, sizeOfMatrix); double E = material.GetE(); double nu = material.GetNu(); StiffnessMatrix sm = new StiffnessMatrix(E, nu); for (int i = 0; i < elements.Count; i++) { List <int> connectedNodes = elements[i].GetConnectivity(); List <Node> nodes = elements[i].GetVertices(); (Matrix <double> Ke, List <Matrix <Double> > Be) = sm.CreateMatrix(nodes); elements[i].SetStiffnessMatrix(Ke); elements[i].SetBMatrices(Be); Ktot = AssemblyMatrix(Ktot, Ke, connectedNodes); } return(Ktot); }
protected override KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector) { KeyedSquareMatrix<NodalDegreeOfFreedom> inverse = stiffnessMatrix.Inverse(); KeyedVector<NodalDegreeOfFreedom> solution = inverse.Multiply(forceVector); return solution; }
/// <summary> /// This function iterates through all the elements which provide stiffnesses for the given combination of nodal degree of freedoms /// and sums them to provide the total stiffness /// </summary> /// <param name="rowKeys">The nodal degree of freedoms which represent the rows of the matrix</param> /// <param name="columnKeys">The nodal degree of freedoms which represents the columns of the matrix</param> /// <returns>A matrix representing the stiffness for these combinations of rows and columns</returns> private StiffnessMatrix BuildStiffnessSubMatrix(IList<NodalDegreeOfFreedom> rowKeys, IList<NodalDegreeOfFreedom> columnKeys) { Guard.AgainstNullArgument(rowKeys, "rowKeys"); Guard.AgainstNullArgument(columnKeys, "columnKeys"); int numRows = rowKeys.Count; int numCols = columnKeys.Count; Guard.AgainstBadArgument( "rowKeys", () => { return numRows == 0; }, "There must be at least one row"); Guard.AgainstBadArgument( "columnKeys", () => { return numCols == 0; }, "There must be at least one column"); StiffnessMatrix result = new StiffnessMatrix(rowKeys, columnKeys); IList<IFiniteElement> connectedElements; foreach (NodalDegreeOfFreedom row in rowKeys) { foreach (NodalDegreeOfFreedom column in columnKeys) { connectedElements = this.parent.AllElementsDirectlyConnecting(row.Node, column.Node); double currentResult = this.SumStiffnessesForAllElementsAt(connectedElements, row, column); if (!currentResult.IsApproximatelyEqualTo(0.0)) { result.At(row, column, currentResult); } } } return result; }
/// <summary> /// Solves AX=B for X. /// </summary> /// <param name="stiffnessMatrix">The stiffness matrix</param> /// <param name="forceVector">The forces</param> /// <returns></returns> protected abstract KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector);
/// <summary> /// Solves AX=B for X. /// </summary> /// <param name="stiffnessMatrix">The stiffness matrix</param> /// <param name="forceVector">The forces</param> /// <returns></returns> protected abstract KeyedVector <NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector <NodalDegreeOfFreedom> forceVector);
/// <summary> /// /// </summary> /// <param name="stiffnessMatrix"></param> /// <param name="forceVector"></param> /// <returns></returns> protected override KeyedVector<NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector<NodalDegreeOfFreedom> forceVector) { Svd<NodalDegreeOfFreedom, NodalDegreeOfFreedom> svd = new Svd<NodalDegreeOfFreedom, NodalDegreeOfFreedom>(stiffnessMatrix, true); return svd.Solve(forceVector); }
/// <summary> /// /// </summary> /// <param name="stiffnessMatrix"></param> /// <param name="forceVector"></param> /// <returns></returns> protected override KeyedVector <NodalDegreeOfFreedom> Solve(StiffnessMatrix stiffnessMatrix, KeyedVector <NodalDegreeOfFreedom> forceVector) { Svd <NodalDegreeOfFreedom, NodalDegreeOfFreedom> svd = new Svd <NodalDegreeOfFreedom, NodalDegreeOfFreedom>(stiffnessMatrix, true); return(svd.Solve(forceVector)); }