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));
}
