예제 #1
0
        /// <summary>
        /// Determines whether defined matrix is diagonal matrix or not.
        /// Diagonal matrix is a matrix that only have nonzero elements on its main diagonal.
        /// </summary>
        /// <param name="mtx">The MTX.</param>
        /// <returns></returns>
        public static bool IsDiagonalMatrix(this CCS mtx)
        {
            var n = mtx.ColumnCount;

            if (n != mtx.RowCount)
            {
                return(false);
            }

            if (mtx.Values.Length > n)
            {
                return(false);
            }

            for (int i = 0; i < n; i++)
            {
                var col = i;

                var st = mtx.ColumnPointers[i];
                var en = mtx.ColumnPointers[i + 1];

                for (int j = st; j < en; j++)
                {
                    var row = mtx.RowIndices[j];

                    if (row != col)
                    {
                        return(false);
                    }
                }
            }


            return(true);
        }
예제 #2
0
        /// <summary>
        /// Gets the reduced zone divided matrix.
        /// </summary>
        /// <param name="reducedMatrix">The reduced matrix.</param>
        /// <param name="map">The map.</param>
        /// <returns></returns>
        public static ZoneDevidedMatrix GetReducedZoneDividedMatrix(CCS reducedMatrix, DofMappingManager map)
        {
            var m = map.M;
            var n = map.N;
            var r = reducedMatrix;

            if (r.ColumnCount != r.RowCount || r.RowCount != 6 * m)
            {
                throw new InvalidOperationException();
            }

            var ff = new Coord(map.RMap2.Length, map.RMap2.Length);
            var fs = new Coord(map.RMap2.Length, map.RMap3.Length);
            var sf = new Coord(map.RMap3.Length, map.RMap2.Length);
            var ss = new Coord(map.RMap3.Length, map.RMap3.Length);

            for (var i = 0; i < 6 * m; i++)
            {
                var st = r.ColumnPointers[i];
                var en = r.ColumnPointers[i + 1];

                var col = i;

                for (var j = st; j < en; j++)
                {
                    var row = r.RowIndices[j];
                    var val = r.Values[j];

                    if (map.Fixity[map.RMap1[row]] == DofConstraint.Released &&
                        map.Fixity[map.RMap1[col]] == DofConstraint.Released)
                    {
                        ff.At(map.Map2[row], map.Map2[col], val);
                    }

                    if (map.Fixity[map.RMap1[row]] == DofConstraint.Released &&
                        map.Fixity[map.RMap1[col]] != DofConstraint.Released)
                    {
                        fs.At(map.Map2[row], map.Map3[col], val);
                    }

                    if (map.Fixity[map.RMap1[row]] != DofConstraint.Released &&
                        map.Fixity[map.RMap1[col]] == DofConstraint.Released)
                    {
                        sf.At(map.Map3[row], map.Map2[col], val);
                    }

                    if (map.Fixity[map.RMap1[row]] != DofConstraint.Released &&
                        map.Fixity[map.RMap1[col]] != DofConstraint.Released)
                    {
                        ss.At(map.Map3[row], map.Map3[col], val);
                    }
                }
            }

            var buf = new ZoneDevidedMatrix();

            buf.ReleasedReleasedPart = ff.ToCCs();
            buf.ReleasedFixedPart    = fs.ToCCs();
            buf.FixedReleasedPart    = sf.ToCCs();
            buf.FixedFixedPart       = ss.ToCCs();

            return(buf);
        }