public IMatrix DampingMatrix(IElement element) { IMatrix damping = BuildStiffnessMatrix(); damping.ScaleIntoThis(dynamicProperties.RayleighCoeffStiffness); damping.AxpyIntoThis(MassMatrix(element), dynamicProperties.RayleighCoeffMass); return(damping); }
private IMatrixView CalculateEffectiveMatrixInternal(ImplicitIntegrationCoefficients coefficients, ISubdomain subdomain) { int id = subdomain.ID; IMatrix matrix = this.Ks[id]; matrix.LinearCombinationIntoThis(coefficients.Stiffness, Ms[id], coefficients.Mass); matrix.AxpyIntoThis(Cs[id], coefficients.Damping); return(matrix); }
public virtual IMatrix DampingMatrix(IElement element) { IMatrix damping = StiffnessMatrix(element); damping.ScaleIntoThis(dynamicProperties.RayleighCoeffStiffness); damping.AxpyIntoThis(MassMatrix(element), dynamicProperties.RayleighCoeffMass); //IMatrix damping = null; return(damping); }
public IMatrixView LinearCombinationOfMatricesIntoStiffness(ImplicitIntegrationCoefficients coefficients, ISubdomain subdomain) { //TODO: 1) Why do we want Ks to be built only if it has not been factorized? // 2) When calling Ks[id], the matrix will be built anyway, due to the annoying side effects of the property. // Therefore, if the matrix was indeed factorized it would be built twice! // 3) The provider should be decoupled from solver logic, such as knowing if the matrix is factorized. Knowledge // that the matrix has been altered by the solver could be implemented by observers, if necessary. // 4) The analyzer should decide when global matrices need to be rebuilt, not the provider. // 5) The need to rebuild the system matrix if the solver has modified it might be avoidable if the analyzer // uses the appropriate order of operations. However, that may not always be possible. Such a feature // (rebuild or store) is nice to have. Whow would be responsible, the solver, provider or assembler? // 6) If the analyzer needs the system matrix, then it can call solver.PreventFromOverwritingMatrix(). E.g. // explicit dynamic analyzers would need to do that. //if (linearSystem.IsMatrixOverwrittenBySolver) BuildKs(); int id = subdomain.ID; IMatrix matrix = this.StiffnessFreeFree[id]; matrix.LinearCombinationIntoThis(coefficients.Stiffness, Mass[id], coefficients.Mass); matrix.AxpyIntoThis(Damping[id], coefficients.Damping); return(matrix); }
/// <summary> /// Performs the operation: /// <paramref name="matrix1"/>[i, j] = <paramref name="matrix1"/>[i, j] + <paramref name="matrix2"/>[i, j], /// for 0 <= i < <see cref="IIndexable2D.NumRows"/>, 0 <= j < <see cref="IIndexable2D.NumColumns"/>. /// The resulting matrix overwrites the entries of <paramref name="matrix1"/>. /// </summary> /// <param name="matrix1">The first <see cref="IMatrix"/> operand. It must have as many rows and columns as /// <paramref name="matrix2"/>.</param> /// <param name="matrix2">The second <see cref="IMatrixView"/> operand. It must have as many rows and columns as /// <paramref name="matrix1"/>.</param> /// <exception cref="NonMatchingDimensionsException">Thrown if <paramref name="matrix1"/> and <paramref name="matrix2"/> /// have a different number of <see cref="IIndexable2D.NumRows"/> or /// <see cref="IIndexable2D.NumColumns"/>.</exception> /// <exception cref="PatternModifiedException">Thrown if an <paramref name="matrix1"/>[i, j] needs to be /// overwritten, but that is not permitted by the matrix storage format.</exception> public static void AddIntoThis(this IMatrix matrix1, IMatrixView matrix2) => matrix1.AxpyIntoThis(matrix2, 1.0);