Beispiel #1
0
        private Matrix CalculateConstitutiveMatrix(NurbsKirchhoffLoveShellElement element, Vector surfaceBasisVector1, Vector surfaceBasisVector2)
        {
            var auxMatrix1 = Matrix.CreateZero(2, 2);

            auxMatrix1[0, 0]             = surfaceBasisVector1.DotProduct(surfaceBasisVector1);
            auxMatrix1[0, 1]             = surfaceBasisVector1.DotProduct(surfaceBasisVector2);
            auxMatrix1[1, 0]             = surfaceBasisVector2.DotProduct(surfaceBasisVector1);
            auxMatrix1[1, 1]             = surfaceBasisVector2.DotProduct(surfaceBasisVector2);
            (Matrix inverse, double det) = auxMatrix1.InvertAndDeterminant();

            var material           = ((IContinuumMaterial2D)element.Patch.Material);
            var constitutiveMatrix = Matrix.CreateFromArray(new double[3, 3]
            {
                {
                    inverse[0, 0] * inverse[0, 0],
                    material.PoissonRatio * inverse[0, 0] * inverse[1, 1] + (1 - material.PoissonRatio) * inverse[1, 0] * inverse[1, 0],
                    inverse[0, 0] * inverse[1, 0]
                },
                {
                    material.PoissonRatio *inverse[0, 0] * inverse[1, 1] + (1 - material.PoissonRatio) * inverse[1, 0] * inverse[1, 0],
                    inverse[1, 1] * inverse[1, 1],
                    inverse[1, 1] * inverse[1, 0]
                },
                {
                    inverse[0, 0] * inverse[1, 0],
                    inverse[1, 1] * inverse[1, 0],
                    0.5 * (1 - material.PoissonRatio) * inverse[0, 0] * inverse[1, 1] + (1 + material.PoissonRatio) * inverse[1, 0] * inverse[1, 0]
                },
            });

            return(constitutiveMatrix);
        }
Beispiel #2
0
        private static Matrix CalculateJacobian(NurbsKirchhoffLoveShellElement shellElement, Nurbs2D nurbs, int j)
        {
            var    elementControlPoints = shellElement.ControlPoints.ToArray();
            Matrix jacobianMatrix       = Matrix.CreateZero(2, 3);

            for (int k = 0; k < elementControlPoints.Length; k++)
            {
                jacobianMatrix[0, 0] += nurbs.NurbsDerivativeValuesKsi[k, j] * elementControlPoints[k].X;
                jacobianMatrix[0, 1] += nurbs.NurbsDerivativeValuesKsi[k, j] * elementControlPoints[k].Y;
                jacobianMatrix[0, 2] += nurbs.NurbsDerivativeValuesKsi[k, j] * elementControlPoints[k].Z;
                jacobianMatrix[1, 0] += nurbs.NurbsDerivativeValuesHeta[k, j] * elementControlPoints[k].X;
                jacobianMatrix[1, 1] += nurbs.NurbsDerivativeValuesHeta[k, j] * elementControlPoints[k].Y;
                jacobianMatrix[1, 2] += nurbs.NurbsDerivativeValuesHeta[k, j] * elementControlPoints[k].Z;
            }

            return(jacobianMatrix);
        }
Beispiel #3
0
        private static Matrix CalculateHessian(NurbsKirchhoffLoveShellElement shellElement, Nurbs2D nurbs, int j)
        {
            var    elementControlPoints = shellElement.ControlPoints.ToArray();
            Matrix hessianMatrix        = Matrix.CreateZero(3, 3);

            for (int k = 0; k < elementControlPoints.Length; k++)
            {
                hessianMatrix[0, 0] += nurbs.NurbsSecondDerivativeValueKsi[k, j] * elementControlPoints[k].X;
                hessianMatrix[0, 1] += nurbs.NurbsSecondDerivativeValueKsi[k, j] * elementControlPoints[k].Y;
                hessianMatrix[0, 2] += nurbs.NurbsSecondDerivativeValueKsi[k, j] * elementControlPoints[k].Z;
                hessianMatrix[1, 0] += nurbs.NurbsSecondDerivativeValueHeta[k, j] * elementControlPoints[k].X;
                hessianMatrix[1, 1] += nurbs.NurbsSecondDerivativeValueHeta[k, j] * elementControlPoints[k].Y;
                hessianMatrix[1, 2] += nurbs.NurbsSecondDerivativeValueHeta[k, j] * elementControlPoints[k].Z;
                hessianMatrix[2, 0] += nurbs.NurbsSecondDerivativeValueKsiHeta[k, j] * elementControlPoints[k].X;
                hessianMatrix[2, 1] += nurbs.NurbsSecondDerivativeValueKsiHeta[k, j] * elementControlPoints[k].Y;
                hessianMatrix[2, 2] += nurbs.NurbsSecondDerivativeValueKsiHeta[k, j] * elementControlPoints[k].Z;
            }

            return(hessianMatrix);
        }
Beispiel #4
0
        private Matrix CalculateMembraneDeformationMatrix(Nurbs2D nurbs, int j, Vector surfaceBasisVector1,
                                                          Vector surfaceBasisVector2, NurbsKirchhoffLoveShellElement element)
        {
            var    elementControlPoints = element.ControlPoints.ToArray();
            Matrix dRIa = Matrix.CreateZero(3, elementControlPoints.Length);

            for (int i = 0; i < elementControlPoints.Length; i++)
            {
                for (int m = 0; m < 3; m++)
                {
                    dRIa[m, i] = nurbs.NurbsDerivativeValuesHeta[i, j] * surfaceBasisVector1[m] +
                                 nurbs.NurbsDerivativeValuesKsi[i, j] * surfaceBasisVector2[m];
                }
            }

            Matrix Bmembrane = Matrix.CreateZero(3, elementControlPoints.Length * 3);

            for (int column = 0; column < elementControlPoints.Length * 3; column += 3)
            {
                Bmembrane[0, column]     = nurbs.NurbsDerivativeValuesKsi[column / 3, j] * surfaceBasisVector1[0];
                Bmembrane[0, column + 1] = nurbs.NurbsDerivativeValuesKsi[column / 3, j] * surfaceBasisVector1[1];
                Bmembrane[0, column + 2] = nurbs.NurbsDerivativeValuesKsi[column / 3, j] * surfaceBasisVector1[2];

                Bmembrane[1, column]     = nurbs.NurbsDerivativeValuesHeta[column / 3, j] * surfaceBasisVector2[0];
                Bmembrane[1, column + 1] = nurbs.NurbsDerivativeValuesHeta[column / 3, j] * surfaceBasisVector2[1];
                Bmembrane[1, column + 2] = nurbs.NurbsDerivativeValuesHeta[column / 3, j] * surfaceBasisVector2[2];

                Bmembrane[2, column]     = dRIa[0, column / 3];
                Bmembrane[2, column + 1] = dRIa[1, column / 3];
                Bmembrane[2, column + 2] = dRIa[2, column / 3];
            }

            return(Bmembrane);
        }
Beispiel #5
0
        private Matrix CalculateBendingDeformationMatrix(Vector surfaceBasisVector3, Nurbs2D nurbs, int j,
                                                         Vector surfaceBasisVector2, Vector surfaceBasisVectorDerivative1, Vector surfaceBasisVector1, double J1,
                                                         Vector surfaceBasisVectorDerivative2, Vector surfaceBasisVectorDerivative12, NurbsKirchhoffLoveShellElement element)
        {
            var    elementControlPoints = element.ControlPoints.ToArray();
            Matrix Bbending             = Matrix.CreateZero(3, elementControlPoints.Length * 3);

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

                var BI1 = surfaceBasisVector3.CrossProduct(surfaceBasisVector3);
                BI1.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                var auxVector = surfaceBasisVector2.CrossProduct(surfaceBasisVector3);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesKsi[column / 3, j]);
                BI1.AddIntoThis(auxVector);
                BI1.ScaleIntoThis(surfaceBasisVector3.DotProduct(surfaceBasisVectorDerivative1));
                auxVector = surfaceBasisVector1.CrossProduct(surfaceBasisVectorDerivative1);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                BI1.AddIntoThis(auxVector);
                BI1.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-nurbs.NurbsSecondDerivativeValueKsi[column / 3, j]);
                BI1.AddIntoThis(auxVector);

                #endregion BI1

                #region BI2

                Vector BI2 = surfaceBasisVector3.CrossProduct(surfaceBasisVector3);
                BI2.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                auxVector = surfaceBasisVector2.CrossProduct(surfaceBasisVector3);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesKsi[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                BI2.ScaleIntoThis(surfaceBasisVector3.DotProduct(surfaceBasisVectorDerivative2));
                auxVector = surfaceBasisVector1.CrossProduct(surfaceBasisVectorDerivative2);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                auxVector = surfaceBasisVectorDerivative2.CrossProduct(surfaceBasisVector2);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesKsi[column / 3, j]);
                BI2.AddIntoThis(auxVector);
                BI2.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-nurbs.NurbsSecondDerivativeValueHeta[column / 3, j]);
                BI2.AddIntoThis(auxVector);

                #endregion BI2

                #region BI3

                Vector BI3 = surfaceBasisVector3.CrossProduct(surfaceBasisVector3);
                BI3.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                auxVector = surfaceBasisVector2.CrossProduct(surfaceBasisVector3);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesKsi[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                BI3.ScaleIntoThis(surfaceBasisVector3.DotProduct(surfaceBasisVectorDerivative12));
                auxVector = surfaceBasisVector1.CrossProduct(surfaceBasisVectorDerivative12);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesHeta[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                auxVector = surfaceBasisVectorDerivative2.CrossProduct(surfaceBasisVector2);
                auxVector.ScaleIntoThis(nurbs.NurbsDerivativeValuesKsi[column / 3, j]);
                BI3.AddIntoThis(auxVector);
                BI3.ScaleIntoThis(1 / J1);
                auxVector[0] = surfaceBasisVector3[0];
                auxVector[1] = surfaceBasisVector3[1];
                auxVector[2] = surfaceBasisVector3[2];
                auxVector.ScaleIntoThis(-nurbs.NurbsSecondDerivativeValueKsiHeta[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);
        }