private IVector CalculateRhsImplicit(ILinearSystem linearSystem, int modelNo, bool addRhs)
        {
            //TODO: what is the meaning of addRhs? Do we need this when solving dynamic thermal equations?
            //TODO: stabilizingRhs has not been implemented

            // result = -dt(conductuvity*temperature + rhs -dt(stabilizingConductivity*temperature + StabilizingRhs))
            int id = linearSystem.Subdomain.ID;

            //TODO: instead of creating a new Vector and then trying to set ILinearSystem.RhsVector, clear it and operate on it.

            // uu = a0 * v + a2 * v1 + a3 * v2
            uu[modelNo][id] = v[modelNo][id].LinearCombination(a0, v1[modelNo][id], a2);
            uu[modelNo][id].AxpyIntoThis(v2[modelNo][id], a3);

            // uc = a1 * v + a4 * v1 + a5 * v2
            uc[modelNo][id] = v[modelNo][id].LinearCombination(a1, v1[modelNo][id], a4);
            uc[modelNo][id].AxpyIntoThis(v2[modelNo][id], a5);

            uum[modelNo][id] = providers[modelNo].MassMatrixVectorProduct(linearSystem.Subdomain, uu[modelNo][id]);
            ucc[modelNo][id] = providers[modelNo].DampingMatrixVectorProduct(linearSystem.Subdomain, uc[modelNo][id]);

            IVector rhsResult = uum[modelNo][id].Add(ucc[modelNo][id]);

            if (addRhs)
            {
                rhsResult.AddIntoThis(rhs[modelNo][id]);
            }
            return(rhsResult);
        }
        private IVector CalculateRhsImplicit(ILinearSystem linearSystem, bool addRhs)
        {
            int id = linearSystem.Subdomain.ID;

            uu[id] = v[id].LinearCombination(a0, v1[id], a2);
            uu[id].AxpyIntoThis(v2[id], a3);

            uc[id] = v[id].LinearCombination(a1, v1[id], a4);
            uc[id].AxpyIntoThis(v2[id], a5);

            uum[id] = provider.MassMatrixVectorProduct(linearSystem.Subdomain, uu[id]);
            ucc[id] = provider.DampingMatrixVectorProduct(linearSystem.Subdomain, uc[id]);

            IVector rhsResult = uum[id].Add(ucc[id]);

            if (addRhs)
            {
                rhsResult.AddIntoThis(rhs[id]);
            }

            return(rhsResult);
        }
Beispiel #3
0
        private IVector CalculateRhsImplicit(ILinearSystem linearSystem, bool addRhs)
        {
            //TODO: instead of creating a new Vector and then trying to set ILinearSystem.RhsVector, clear it and operate on it.
            int id = linearSystem.Subdomain.ID;

            // uu = a0 * v + a2 * v1 + a3 * v2
            uu[id] = v[id].LinearCombination(a0, v1[id], a2);
            uu[id].AxpyIntoThis(v2[id], a3);

            // uc = a1 * v + a4 * v1 + a5 * v2
            uc[id] = v[id].LinearCombination(a1, v1[id], a4);
            uc[id].AxpyIntoThis(v2[id], a5);

            uum[id] = provider.MassMatrixVectorProduct(linearSystem.Subdomain, uu[id]);
            ucc[id] = provider.DampingMatrixVectorProduct(linearSystem.Subdomain, uc[id]);

            IVector rhsResult = uum[id].Add(ucc[id]);

            if (addRhs)
            {
                rhsResult.AddIntoThis(rhs[id]);
            }
            return(rhsResult);
        }
Beispiel #4
0
 public void ProcessInternalRhs(ISubdomain subdomain, IVectorView solution, IVector rhs)
 {
     rhs.AddIntoThis(qs[subdomain.ID].Multiply(solution));
     ScaleSubdomainSolidVector(subdomain, rhs);
 }
        private double[,] CalculateBendingDeformationMatrix(double[] surfaceBasisVector3, ShapeTSplines2DFromBezierExtraction tsplines, int j,
                                                            double[] surfaceBasisVector2, double[] surfaceBasisVectorDerivative1, double[] surfaceBasisVector1, double J1,
                                                            double[] surfaceBasisVectorDerivative2, double[] surfaceBasisVectorDerivative12, ControlPoint[] elementControlPoints)
        {
            var Bbending = new double[3, elementControlPoints.Length * 3];
            var s1       = Vector.CreateFromArray(surfaceBasisVector1);
            var s2       = Vector.CreateFromArray(surfaceBasisVector2);
            var s3       = Vector.CreateFromArray(surfaceBasisVector3);
            var s11      = Vector.CreateFromArray(surfaceBasisVectorDerivative1);
            var s22      = Vector.CreateFromArray(surfaceBasisVectorDerivative2);
            var s12      = Vector.CreateFromArray(surfaceBasisVectorDerivative12);

            for (int column = 0; column < elementControlPoints.Length * 3; column += 3)
            {
                #region BI1

                var BI1 = s3.CrossProduct(s3);
                BI1.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                var auxVector = s2.CrossProduct(s3);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesKsi[column / 3, j]);
                BI1.AddIntoThis(auxVector);
                BI1.ScaleIntoThis(s3.DotProduct(s11));
                auxVector = s1.CrossProduct(s11);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                BI1.AddIntoThis(auxVector);
                BI1.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-tsplines.TSplineSecondDerivativesValueKsi[column / 3, j]);
                BI1.AddIntoThis(auxVector);

                #endregion BI1

                #region BI2

                IVector BI2 = s3.CrossProduct(s3);
                BI2.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                auxVector = s2.CrossProduct(s3);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesKsi[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                BI2.ScaleIntoThis(s3.DotProduct(s22));
                auxVector = s1.CrossProduct(s22);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                auxVector = s22.CrossProduct(s2);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesKsi[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                BI2.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-tsplines.TSplineSecondDerivativesValueHeta[column / 3, j]);
                BI2.AddIntoThis(auxVector);

                #endregion BI2

                #region BI3

                Vector BI3 = s3.CrossProduct(s3);
                BI3.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                auxVector = s2.CrossProduct(s3);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesKsi[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                BI3.ScaleIntoThis(s3.DotProduct(s12));
                auxVector = s1.CrossProduct(s12);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesHeta[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                auxVector = s22.CrossProduct(s2);
                auxVector.ScaleIntoThis(tsplines.TSplineDerivativeValuesKsi[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                BI3.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-tsplines.TSplineSecondDerivativesValueKsiHeta[column / 3, j]);
                BI3.AddIntoThis(auxVector);

                #endregion BI3

                Bbending[0, column]     = BI1[0];
                Bbending[0, column + 1] = BI1[1];
                Bbending[0, column + 2] = BI1[2];

                Bbending[1, column]     = BI2[0];
                Bbending[1, column + 1] = BI2[1];
                Bbending[1, column + 2] = BI2[2];

                Bbending[2, column]     = 2 * BI3[0];
                Bbending[2, column + 1] = 2 * BI3[1];
                Bbending[2, column + 2] = 2 * BI3[2];
            }

            return(Bbending);
        }