protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt) { //phystime = 1.8; LsUpdate(phystime); // operator-matrix assemblieren OperatorMatrix = new BlockMsrMatrix(ProblemMapping); AltOperatorMatrix = new MsrMatrix(ProblemMapping); double[] Affine = new double[OperatorMatrix.RowPartitioning.LocalLength]; MultiphaseCellAgglomerator Agg; // Agglomerator setup //Agg = new MultiphaseCellAgglomerator(new CutCellMetrics(MomentFittingVariant, m_quadOrder, LsTrk, LsTrk.GetSpeciesId("B")), this.THRESHOLD, false); Agg = LsTrk.GetAgglomerator(new SpeciesId[] { LsTrk.GetSpeciesId("B") }, m_quadOrder, __AgglomerationTreshold: this.THRESHOLD); Console.WriteLine("Inter-Process agglomeration? " + Agg.GetAgglomerator(LsTrk.GetSpeciesId("B")).AggInfo.InterProcessAgglomeration); // operator matrix assembly Op.ComputeMatrixEx(LsTrk, ProblemMapping, null, ProblemMapping, OperatorMatrix, Affine, false, 0.0, true, Agg.CellLengthScales, null, null, LsTrk.SpeciesIdS.ToArray()); Agg.ManipulateMatrixAndRHS(OperatorMatrix, Affine, this.ProblemMapping, this.ProblemMapping); Op.ComputeMatrixEx(LsTrk, ProblemMapping, null, ProblemMapping, AltOperatorMatrix, Affine, false, 0.0, true, Agg.CellLengthScales, null, null, LsTrk.SpeciesIdS.ToArray()); Agg.ManipulateMatrixAndRHS(AltOperatorMatrix, Affine, this.ProblemMapping, this.ProblemMapping); int nnz = this.OperatorMatrix.GetTotalNoOfNonZeros(); Console.WriteLine("Number of non-zeros in matrix: " + nnz); int nnz2 = this.AltOperatorMatrix.GetTotalNoOfNonZeros(); Assert.IsTrue(nnz == nnz2, "Number of non-zeros in matrix different for " + OperatorMatrix.GetType() + " and " + AltOperatorMatrix.GetType()); Console.WriteLine("Number of non-zeros in matrix (reference): " + nnz2); MsrMatrix Comp = AltOperatorMatrix.CloneAs(); Comp.Acc(-1.0, OperatorMatrix); double CompErr = Comp.InfNorm(); double Denom = Math.Max(AltOperatorMatrix.InfNorm(), OperatorMatrix.InfNorm()); double CompErrRel = Denom > Math.Sqrt(double.Epsilon) ? CompErr / Denom : CompErr; Console.WriteLine("Comparison: " + CompErrRel); Assert.LessOrEqual(CompErrRel, 1.0e-7, "Huge difference between MsrMatrix and BlockMsrMatrix."); base.TerminationKey = true; return(0.0); }
public static void RestrictionOfSystemOpTest() { Basis B1 = new Basis(grid, 0), B2 = new Basis(grid, 2); var Map = new UnsetteledCoordinateMapping(B1, B2); var Lev0Basis = new AggregationGridBasis(B2, TestProgram.MgSeq[0]); var Lev1Basis = new AggregationGridBasis(B2, TestProgram.MgSeq[1]); var Lev0 = new MultigridMapping(Map, new AggregationGridBasis[] { Lev0Basis, Lev0Basis }, new int[] { B1.Degree, B2.Degree }); var Lev1 = new MultigridMapping(Map, new AggregationGridBasis[] { Lev1Basis, Lev1Basis }, new int[] { B1.Degree, B2.Degree }); int[] I0col = Lev0.GetSubvectorIndices(new int[] { 0 }); int[] I1col = Lev0.GetSubvectorIndices(new int[] { 1 }); int[] I0row = Lev1.GetSubvectorIndices(new int[] { 0 }); int[] I1row = Lev1.GetSubvectorIndices(new int[] { 1 }); var RestMtx = Lev1.FromOtherLevelMatrix(Lev0); MsrMatrix Rest00 = new MsrMatrix(I0row.Length, I0col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest00, I0row, default(int[]), I0col, default(int[])); MsrMatrix Rest01 = new MsrMatrix(I0row.Length, I1col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest01, I0row, default(int[]), I1col, default(int[])); MsrMatrix Rest10 = new MsrMatrix(I1row.Length, I0col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest10, I1row, default(int[]), I0col, default(int[])); MsrMatrix Rest11 = new MsrMatrix(I1row.Length, I1col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest11, I1row, default(int[]), I1col, default(int[])); Debug.Assert(Rest10.InfNorm() == 0.0); Debug.Assert(Rest01.InfNorm() == 0.0); Debug.Assert(Rest00.InfNorm() != 0.0); Debug.Assert(Rest11.InfNorm() != 0.0); }
public static void RestrictionOfSystemOpTest() { Basis B1 = new Basis(grid, 0), B2 = new Basis(grid, 2); var Map = new UnsetteledCoordinateMapping(B1, B2); AggregationGridBasis[][] aB = AggregationGridBasis.CreateSequence(TestProgram.MgSeq.Take(2), new Basis[] { B1, B2 }); var Lev0 = new MultigridMapping(Map, aB[0], new int[] { B1.Degree, B2.Degree }); var Lev1 = new MultigridMapping(Map, aB[1], new int[] { B1.Degree, B2.Degree }); int[] I0col = Lev0.GetSubvectorIndices(new int[] { 0 }); int[] I1col = Lev0.GetSubvectorIndices(new int[] { 1 }); int[] I0row = Lev1.GetSubvectorIndices(new int[] { 0 }); int[] I1row = Lev1.GetSubvectorIndices(new int[] { 1 }); var RestMtx = Lev1.FromOtherLevelMatrix(Lev0); MsrMatrix Rest00 = new MsrMatrix(I0row.Length, I0col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest00, I0row, default(int[]), I0col, default(int[])); MsrMatrix Rest01 = new MsrMatrix(I0row.Length, I1col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest01, I0row, default(int[]), I1col, default(int[])); MsrMatrix Rest10 = new MsrMatrix(I1row.Length, I0col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest10, I1row, default(int[]), I0col, default(int[])); MsrMatrix Rest11 = new MsrMatrix(I1row.Length, I1col.Length, 1, 1); RestMtx.WriteSubMatrixTo(Rest11, I1row, default(int[]), I1col, default(int[])); Assert.IsTrue(Rest10.InfNorm() == 0.0); Assert.IsTrue(Rest01.InfNorm() == 0.0); Assert.IsTrue(Rest00.InfNorm() != 0.0); Assert.IsTrue(Rest11.InfNorm() != 0.0); }
void ExtractMatrices() { // dispose old solver, if required // =============================== if (this.m_PressureSolver != null) { this.m_PressureSolver.Dispose(); this.m_PressureSolver = null; } // sub-matrices for the Potential Solver // ===================================== int VelocityLength = this.USubMatrixIdx_Row.Length; int PressureLength = this.PSubMatrixIdx_Row.Length; this.PressureGrad = new MsrMatrix(VelocityLength, PressureLength, 1, 1); this.VelocityDiv = new MsrMatrix(PressureLength, VelocityLength, 1, 1); this.Stab = new MsrMatrix(PressureLength, PressureLength, 1, 1); var WholeSystemMatrix = this.m_MgOp.OperatorMatrix; WholeSystemMatrix.WriteSubMatrixTo(PressureGrad, USubMatrixIdx_Row, default(int[]), PSubMatrixIdx_Row, default(int[])); WholeSystemMatrix.WriteSubMatrixTo(VelocityDiv, PSubMatrixIdx_Row, default(int[]), USubMatrixIdx_Row, default(int[])); WholeSystemMatrix.WriteSubMatrixTo(Stab, PSubMatrixIdx_Row, default(int[]), PSubMatrixIdx_Row, default(int[])); // inverse mass matrix // =================== if (this.m_SIMPLEOptions.PotentialSolver_UseMassMatrix) { // extract the mass-matrix block for the velocity part // --------------------------------------------------- MsrMatrix MM = new MsrMatrix(this.PressureGrad.RowPartitioning, this.VelocityDiv.ColPartition); this.m_MgOp.MassMatrix.WriteSubMatrixTo(MM, this.USubMatrixIdx_Row, default(int[]), this.USubMatrixIdx_Row, default(int[])); // invert mass matrix // ------------------ int D = this.LsTrk.GridDat.SpatialDimension; this.invMM = new MsrMatrix(MM.RowPartitioning, MM.ColPartition); MultidimensionalArray Block = new MultidimensionalArray(2); MultidimensionalArray InvBlock = new MultidimensionalArray(2); int iRow0 = MM.RowPartitioning.i0; int JAGG = this.m_MgOp.Mapping.AggGrid.iLogicalCells.NoOfLocalUpdatedCells; int[] DegreeS = this.m_MgOp.Mapping.DgDegree; for (int jagg = 0; jagg < JAGG; jagg++) // loop over aggregate cells... { for (int d = 0; d < D; d++) // loop over velocity components... { int N = this.m_MgOp.Mapping.AggBasis[d].GetLength(jagg, DegreeS[d]); if (Block.GetLength(0) != N) { Block.Allocate(N, N); InvBlock.Allocate(N, N); } for (int n = 0; n < N; n++) { CheckMatrix(MM, iRow0, N, iRow0 + n); for (int m = 0; m < N; m++) { Block[n, m] = MM[iRow0 + n, iRow0 + m]; } } Block.InvertTo(InvBlock); for (int n = 0; n < N; n++) { for (int m = 0; m < N; m++) { this.invMM[iRow0 + n, iRow0 + m] = InvBlock[n, m]; } } iRow0 += N; } } Debug.Assert(iRow0 == MM.RowPartitioning.iE); #if DEBUG var CheckMX = MM * invMM; double TRESH = Math.Max(MM.InfNorm(), invMM.InfNorm()) * 1.0e-10; for (int iRow = CheckMX.RowPartitioning.i0; iRow < CheckMX.RowPartitioning.iE; iRow++) { if (Math.Abs(CheckMX.GetDiagonalElement(iRow) - 1.0) > TRESH) { throw new ArithmeticException("AapproxInverse is not the Inverse of the Aapprox-Matrix"); } } #endif } }
private void ApproximationMatrix() { this.Aapprox = null; this.AapproxInverse = null; //MsrMatrix AapproxComp = null; /* * switch(m_SIMPLEOptions.Option_Approximation_Predictor) { * case ApproxPredictor.MassMatrix: * case ApproxPredictor.LocalizedOperator: { break; } * default: { * Aapprox = ConvDiff.CloneAs(); * //switch (m_SIMPLEOptions.Option_Timestepper) { * // case Timestepper.Steady: break; * // case Timestepper.ImplicitEuler: { * // Aapprox.Acc(1.0 / dt, MassMatrix); * // break; * // } * // default: { * // throw new NotImplementedException("Unknown Timestepper"); * // } * //} * AapproxComp = new MsrMatrix(USubMatrixIdx.Length, USubMatrixIdx.Length, MassMatrix.RowPartitioning.BlockSize / (2 * D), MassMatrix.ColPartition.BlockSize / (2 * D)); * Aapprox.WriteSubMatrixTo(AapproxComp, USubMatrixIdx, default(int[]), USubMatrixIdx, default(int[])); * break; * } * } */ switch (m_SIMPLEOptions.Option_Approximation_Predictor) { case ApproxPredictor.MassMatrix: { BlockMsrMatrix MM; if (!double.IsPositiveInfinity(this.m_SIMPLEOptions.dt)) { // instationary SIMPLE //MM = this.m_MgOp.MassMatrix.CloneAs(); // hier muss ich mir nochmal was überlegen -- // für einige Präkond.-Optionen // (genau jene, welche die XDG-Basen für beide Phasen in Cut-Zellen mischen), // wie etwa // MultigridOperator.Mode.SymPart_DiagBlockEquilib // ist eine Block-Skalierung mit rho_A und rho_B // inkonsistent! // throw new NotImplementedException("todo"); } else { MM = this.m_MgOp.MassMatrix; } Aapprox = new MsrMatrix(this.ConvDiff.RowPartitioning); this.m_MgOp.MassMatrix.WriteSubMatrixTo(Aapprox, this.USubMatrixIdx_Row, default(int[]), this.USubMatrixIdx_Row, default(int[])); //AapproxInverse = MassMatrixInv._ToMsrMatrix();// Aapprox.Invert(); //switch(m_SIMPLEOptions.Option_Timestepper) { // case Timestepper.Steady: break; // case Timestepper.ImplicitEuler: { // Aapprox.Scale(1 + 1.0 / dt); // AapproxInverse.Scale(1 / (1 + 1.0 / dt)); // /*#if DEBUG // var CheckMX = AapproxInverse * Aapprox; // foreach (int i in USubMatrixIdx) { // if (Math.Abs(CheckMX.GetDiagonalElement(i) - 1.0) > 1e-10) throw new ArithmeticException("AapproxInverse is not the Inverse of the Aapprox-Matrix"); // } // #endif*/ // break; // } // default: { // throw new NotImplementedException("Unknown Timestepper"); // } //} break; } case ApproxPredictor.Exact: { if (this.LsTrk.GridDat.CellPartitioning.MpiSize > 1) { throw new NotSupportedException("Not implemented for MPI-parallel runs."); } //RowIdx = VelocityMapping.GetSubvectorIndices(this.LsTrk, D.ForLoop(d => d), _SpcIds: this.LsTrk.SpeciesIdS, drk: this.TransportAgglomerator); //ColIdx = RowIdx; if (USubMatrixIdx_Row.Length > 4500) { Console.WriteLine(string.Format("WARNING: you don't really want to invert a {0}x{0} matrix.", USubMatrixIdx_Row.Length)); } this.Aapprox = this.ConvDiff; MultidimensionalArray AapproxFull = Aapprox.ToFullMatrixOnProc0(); MultidimensionalArray AapproxInverseFull = AapproxFull.GetInverse(); this.AapproxInverse = new MsrMatrix(new Partitioning(USubMatrixIdx_Row.Length)); this.AapproxInverse.AccDenseMatrix(1.0, AapproxInverseFull); break; } case ApproxPredictor.Diagonal: { /* * Aapprox = new MsrMatrix(ConvDiff.RowPartitioning, ConvDiff.ColPartition); * AapproxInverse = new MsrMatrix(ConvDiff.RowPartitioning, ConvDiff.ColPartition); * foreach(int i in USubMatrixIdx) { * int[] j = new int[] { i }; * double Value = ConvDiff.GetValues(i, j)[0]; * //Value += MassMatrix.GetValues(i, j)[0]; * Aapprox.SetDiagonalElement(i, Value); * if(Value == 0) { * AapproxInverse.SetDiagonalElement(i, 0); * } else { * AapproxInverse.SetDiagonalElement(i, 1 / Value); * } * } #if DEBUG * Aapprox.VerifyDataStructure(); * AapproxInverse.VerifyDataStructure(); * var CheckMX = AapproxInverse * Aapprox; * foreach(int i in USubMatrixIdx) { * if(Math.Abs(CheckMX.GetDiagonalElement(i) - 1.0) > 1e-13) throw new ArithmeticException("AapproxInverse is not the Inverse of the Operator Matrix"); * } #endif * break; */ throw new NotImplementedException("todo"); } case ApproxPredictor.BlockDiagonal: { /* * AapproxInverse = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * var AapproxCompBD = new BlockDiagonalMatrix(AapproxComp); * var AapproxCompInvBD = AapproxCompBD.Invert(); * AapproxCompBD._ToMsrMatrix().WriteSubMatrixTo(Aapprox, default(int[]), USubMatrixIdx, default(int[]), USubMatrixIdx); * AapproxCompInvBD._ToMsrMatrix().WriteSubMatrixTo(AapproxInverse, default(int[]), USubMatrixIdx, default(int[]), USubMatrixIdx); * //#if DEBUG * Aapprox.VerifyDataStructure(); * AapproxInverse.VerifyDataStructure(); * var CheckMX = AapproxInverse * Aapprox; * foreach(int i in USubMatrixIdx) { * if(Math.Abs(CheckMX.GetDiagonalElement(i) - 1.0) > 1e-12) throw new ArithmeticException("AapproxInverse is not the Inverse of the Operator Matrix"); * } * //#endif * * break; */ throw new NotImplementedException("todo"); } case ApproxPredictor.BlockSum: { /* * Console.WriteLine("BlockSum is not properly tested yet and did not work in previous tests"); * int AccdBlockSize = ConvDiff.RowPartitioning.BlockSize / (2 * D); * var AapproxBD = new BlockDiagonalMatrix(ConvDiff.RowPartitioning); * var Aapprox = new MsrMatrix(ConvDiff.RowPartitioning); * int[] indexer = new int[AccdBlockSize]; * for(int i = 0; i < indexer.Length; i++) { * indexer[i] = i; * } * int[] rowindexer = indexer.CloneAs(); * * * for(int i = 0; i < ConvDiff.NoOfRows / AccdBlockSize; i++) { * int[] colindexer = indexer.CloneAs(); * for(int j = 0; j < ConvDiff.NoOfCols / AccdBlockSize; j++) { * ConvDiff.AccSubMatrixTo(1.0, Aapprox, rowindexer, rowindexer, colindexer, rowindexer); * for(int r = 0; r < indexer.Length; r++) { * colindexer[r] += AccdBlockSize; * } * } * for(int r = 0; r < indexer.Length; r++) { * rowindexer[r] += AccdBlockSize; * } * } * //if (m_SIMPLEOptions.Option_Timestepper == Timestepper.ImplicitEuler) { * // Aapprox.Acc(1 / dt, MassMatrix); * //} * AapproxComp = new MsrMatrix(USubMatrixIdx.Length, USubMatrixIdx.Length, AccdBlockSize, AccdBlockSize); * Aapprox.WriteSubMatrixTo(AapproxComp, USubMatrixIdx, default(int[]), USubMatrixIdx, default(int[])); * AapproxInverse = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * var AapproxCompBD = new BlockDiagonalMatrix(AapproxComp); * var AapproxCompInvBD = AapproxCompBD.Invert(); * AapproxCompInvBD._ToMsrMatrix().WriteSubMatrixTo(AapproxInverse, default(int[]), USubMatrixIdx, default(int[]), USubMatrixIdx); #if DEBUG * Aapprox.VerifyDataStructure(); * AapproxInverse.VerifyDataStructure(); * * // Check copying back and forth * var CheckAapproxComp = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * AapproxComp.WriteSubMatrixTo(CheckAapproxComp, default(int[]), USubMatrixIdx, default(int[]), USubMatrixIdx); * CheckAapproxComp.Acc(-1.0, Aapprox); * if(CheckAapproxComp.InfNorm() > 1e-14) throw new ArithmeticException("Something went wrong while copying the Aapprox Matrix"); * * //Check Transformation to BlockdiagonalMatrix * var CheckAapproxCompBD = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * AapproxCompBD._ToMsrMatrix().WriteSubMatrixTo(CheckAapproxCompBD, default(int[]), USubMatrixIdx, default(int[]), USubMatrixIdx); * CheckAapproxCompBD.Acc(-1.0, Aapprox); * if(CheckAapproxCompBD.InfNorm() > 1e-14) throw new ArithmeticException("Something went wrong while copying the Aapprox Matrix"); * * //Check Matrix Inversion * var CheckMX = AapproxInverse * Aapprox; * foreach(int i in USubMatrixIdx) { * if(Math.Abs(CheckMX.GetDiagonalElement(i) - 1.0) > 1e-12) throw new ArithmeticException("AapproxInverse is not the Inverse of the Operator Matrix"); * } #endif * break; */ throw new NotImplementedException("todo"); } case ApproxPredictor.Neumann: { /* * Console.WriteLine("Neumann did not work in previous Tests, Series does typically not converge"); * int serieslength = 10; * * Aapprox = ConvDiff.CloneAs(); * //if (m_SIMPLEOptions.Option_Timestepper != Timestepper.Steady) { * // Aapprox.Acc(1.0 / dt, MassMatrix); * //} * var B = Aapprox.CloneAs(); * double ScalingFactor = Aapprox.InfNorm(); * B.Scale((-1.0 / ScalingFactor.Pow(0))); //Scaling Power up to 4 tried * B.AccEyeSp(1.0); * AapproxInverse = B; * AapproxInverse.AccEyeSp(1.0); * MsrMatrix OldMoment = B; * for(int i = 0; i <= serieslength; i++) { * var NewMoment = OldMoment * B; * AapproxInverse.Acc(1.0, NewMoment); * //Debug * Console.WriteLine("MomentNumber #{0}, InfNormOf Inverse #{1}", i, NewMoment.InfNorm()); * OldMoment = NewMoment; * } * AapproxInverse.Scale((1.0 / ScalingFactor.Pow(0))); //Scaling Power up to 4 tried * break; */ throw new NotImplementedException("todo"); } case ApproxPredictor.LocalizedOperator: { /* * Console.WriteLine("Localized Operator did not work in previous Tests"); * double[] LocalizedOpAffine; * MultiphaseCellAgglomerator LocalizedAgglomerator; * Aapprox = new MsrMatrix(MassMatrix.RowPartitioning, MassMatrix.ColPartition); * TransportOpLocalized.AssembleMatrix( * out Aapprox, out LocalizedOpAffine, * out LocalizedAgglomerator, out TransportMassFact, * this.Velocity.Current, null, * this.LevSet, null, Curv, * VelocityMapping, VelocityMapping); * if(Option_Timestepper == Timestepper.ImplicitEuler) { * Aapprox.Acc(1 / dt, MassMatrix); * } * * var DiagAverage = Aapprox.GetDiagVector().Average(); * foreach(int i in RowIdx) { * if(Aapprox.GetDiagonalElement(i) == 0.0) { * //Aapprox.SetDiagonalElement(i, MassMatrix.GetDiagonalElement(i)); * Aapprox.SetDiagonalElement(i, DiagAverage); * } * } * AapproxComp = new MsrMatrix(RowIdx.Length, RowIdx.Length, MassMatrix.RowPartitioning.BlockSize / (2 * D), MassMatrix.ColPartition.BlockSize / (2 * D)); * Aapprox.WriteSubMatrixTo(AapproxComp, RowIdx, default(int[]), ColIdx, default(int[])); * AapproxInverse = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * var AapproxCompBD = new BlockDiagonalMatrix(AapproxComp); * var AapproxCompInvBD = AapproxCompBD.Invert(); * AapproxCompInvBD._ToMsrMatrix().WriteSubMatrixTo(AapproxInverse, default(int[]), RowIdx, default(int[]), ColIdx); * //AapproxComp._ToMsrMatrix().WriteSubMatrixTo(Aapprox, default(int[]), RowIdx, default(int[]), ColIdx); * * #if DEBUG * Aapprox.VerifyDataStructure(); * AapproxInverse.VerifyDataStructure(); * var CheckAapproxCompBD = new MsrMatrix(Aapprox.RowPartitioning, Aapprox.ColPartition); * AapproxCompBD._ToMsrMatrix().WriteSubMatrixTo(CheckAapproxCompBD, default(int[]), RowIdx, default(int[]), ColIdx); * CheckAapproxCompBD.Acc(-1.0, Aapprox); * if(CheckAapproxCompBD.InfNorm() > 1e-14) throw new ArithmeticException("Something went wrong while copying the Aapprox Matrix"); * var CheckMX = AapproxInverse * Aapprox; * foreach(int i in RowIdx) { * if(Math.Abs(CheckMX.GetDiagonalElement(i) - 1.0) > 1e-12) throw new ArithmeticException("AapproxInverse is not the Inverse of the Operator Matrix"); * } #endif * break; */ throw new NotImplementedException("todo"); } default: throw new NotImplementedException("todo"); } if (this.AapproxInverse == null) { // block-inversion is required. // ++++++++++++++++++++++++++++ int D = this.LsTrk.GridDat.SpatialDimension; this.AapproxInverse = new MsrMatrix(this.Aapprox.RowPartitioning, this.Aapprox.ColPartition); //int N = this.m_MgOp.Mapping.AggBasis.GetMinimalLength(this.m_MgOp.Mapping.DgDegree[0]); //Debug.Assert(this.Aapprox.RowPartitioning.LocalLength % N == 0); MultidimensionalArray Block = new MultidimensionalArray(2); MultidimensionalArray InvBlock = new MultidimensionalArray(2); int iRow0 = this.Aapprox.RowPartitioning.i0; int JAGG = this.m_MgOp.Mapping.AggGrid.iLogicalCells.NoOfLocalUpdatedCells; int[] DegreeS = this.m_MgOp.Mapping.DgDegree; for (int jagg = 0; jagg < JAGG; jagg++) // loop over aggregate cells... { for (int d = 0; d < D; d++) // loop over velocity components... { int N = this.m_MgOp.Mapping.AggBasis[d].GetLength(jagg, DegreeS[d]); if (Block.GetLength(0) != N) { Block.Allocate(N, N); InvBlock.Allocate(N, N); } for (int n = 0; n < N; n++) { #if DEBUG int iRow = iRow0 + n; { int[] Cols = null; double[] Vals = null; int LR = Aapprox.GetRow(iRow, ref Cols, ref Vals); int cMin = int.MaxValue; int cMax = int.MinValue; for (int lr = 0; lr < LR; lr++) { if (Vals[lr] != 0.0) { cMin = Math.Min(cMin, Cols[lr]); cMax = Math.Max(cMax, Cols[lr]); } } Debug.Assert(cMin >= iRow0); Debug.Assert(cMax < iRow0 + N); } #endif for (int m = 0; m < N; m++) { Block[n, m] = this.Aapprox[iRow0 + n, iRow0 + m]; } } Block.InvertTo(InvBlock); for (int n = 0; n < N; n++) { for (int m = 0; m < N; m++) { this.AapproxInverse[iRow0 + n, iRow0 + m] = InvBlock[n, m]; } } iRow0 += N; } } Debug.Assert(iRow0 == this.Aapprox.RowPartitioning.iE); } #if DEBUG var CheckMX = AapproxInverse * Aapprox; double TRESH = Math.Max(AapproxInverse.InfNorm(), Aapprox.InfNorm()) * 1.0e-10; for (int iRow = CheckMX.RowPartitioning.i0; iRow < CheckMX.RowPartitioning.iE; iRow++) { if (Math.Abs(CheckMX.GetDiagonalElement(iRow) - 1.0) > TRESH) { throw new ArithmeticException("AapproxInverse is not the Inverse of the Aapprox-Matrix"); } } #endif }
protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt) { LsUpdate(phystime); // operator-matrix assemblieren OperatorMatrix = new BlockMsrMatrix(MG_Mapping.ProblemMapping); AltOperatorMatrix = new MsrMatrix(MG_Mapping.ProblemMapping); double[] Affine = new double[OperatorMatrix.RowPartitioning.LocalLength]; MultiphaseCellAgglomerator Agg; Agg = LsTrk.GetAgglomerator(this.LsTrk.SpeciesIdS.ToArray(), m_quadOrder, __AgglomerationTreshold: this.THRESHOLD); XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Op.GetMatrixBuilder(base.LsTrk, MG_Mapping.ProblemMapping, null, MG_Mapping.ProblemMapping); mtxBuilder.time = 0.0; mtxBuilder.ComputeMatrix(OperatorMatrix, Affine); Agg.ManipulateMatrixAndRHS(OperatorMatrix, Affine, MG_Mapping.ProblemMapping, MG_Mapping.ProblemMapping); foreach (var S in this.LsTrk.SpeciesNames) { Console.WriteLine(" Species {0}: no of agglomerated cells: {1}", S, Agg.GetAgglomerator(this.LsTrk.GetSpeciesId(S)).AggInfo.SourceCells.NoOfItemsLocally); } MGOp = new MultigridOperator(XAggB, map, OperatorMatrix, this.massFact.GetMassMatrix(map, false), OpConfig, null); Debug.Assert(MGOp.OperatorMatrix != null); Debug.Assert(MGOp.Mapping != null); someVec = GetRHS(Affine, OperatorMatrix); mtxBuilder.ComputeMatrix(AltOperatorMatrix, Affine); Agg.ManipulateMatrixAndRHS(AltOperatorMatrix, Affine, MG_Mapping.ProblemMapping, MG_Mapping.ProblemMapping); //LsTrk.GetSpeciesName(((XdgAggregationBasis)MGOp.Mapping.AggBasis[0]).UsedSpecies[1]); //LsTrk.GetSpeciesName(((XdgAggregationBasis)MGOp.Mapping.AggBasis[0]).UsedSpecies[0]); int nnz = this.OperatorMatrix.GetTotalNoOfNonZeros(); Console.WriteLine("Number of non-zeros in matrix: " + nnz); int nnz2 = this.AltOperatorMatrix.GetTotalNoOfNonZeros(); Assert.IsTrue(nnz == nnz2, "Number of non-zeros in matrix different for " + OperatorMatrix.GetType() + " and " + AltOperatorMatrix.GetType()); Console.WriteLine("Number of non-zeros in matrix (reference): " + nnz2); MsrMatrix Comp = AltOperatorMatrix.CloneAs(); Comp.Acc(-1.0, OperatorMatrix); double CompErr = Comp.InfNorm(); double Denom = Math.Max(AltOperatorMatrix.InfNorm(), OperatorMatrix.InfNorm()); double CompErrRel = Denom > Math.Sqrt(double.Epsilon) ? CompErr / Denom : CompErr; Console.WriteLine("Comparison: " + CompErrRel); Assert.LessOrEqual(CompErrRel, 1.0e-7, "Huge difference between MsrMatrix and BlockMsrMatrix."); base.TerminationKey = true; return(0.0); }
/// <summary> /// Includes assembly of the matrix. /// </summary> /// <param name="L"></param> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { // create operator // =============== SpatialOperator LapaceIp; { double D = this.GridData.SpatialDimension; double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D; double penalty_factor = base.Control.penalty_poisson; BoundaryCondMap <BoundaryType> PoissonBcMap = new BoundaryCondMap <BoundaryType>(this.GridData, this.Control.BoundaryValues, "T"); LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T"); var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, this.GridData.Cells.cj, PoissonBcMap); LapaceIp.EquationComponents["T"].Add(flux); LapaceIp.Commit(); } // Create Matrices // =============== { // time measurement for matrix assembly Stopwatch stw = new Stopwatch(); stw.Start(); // console Console.WriteLine("creating sparse system for {0} DOF's ...", T.Mapping.Ntotal); // quadrature domain var volQrSch = new CellQuadratureScheme(true, CellMask.GetFullMask(this.GridData)); var edgQrSch = new EdgeQuadratureScheme(true, EdgeMask.GetFullMask(this.GridData)); #if DEBUG // in DEBUG mode, we compare 'MsrMatrix' (old, reference implementation) and 'BlockMsrMatrix' (new standard) var RefLaplaceMtx = new MsrMatrix(T.Mapping); #endif using (new BlockTrace("SipMatrixAssembly", tr)) { LaplaceMtx = new BlockMsrMatrix(T.Mapping); LaplaceAffine = new double[T.Mapping.LocalLength]; LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, LaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); } #if DEBUG LaplaceAffine.ClearEntries(); LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, RefLaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); MsrMatrix ErrMtx = RefLaplaceMtx.CloneAs(); ErrMtx.Acc(-1.0, LaplaceMtx); double err = ErrMtx.InfNorm(); double infNrm = LaplaceMtx.InfNorm(); Console.WriteLine("Matrix comparison error: " + err + ", matrix norm is: " + infNrm); Assert.Less(err, infNrm * 1e-10, "MsrMatrix2 comparison failed."); #endif stw.Stop(); Console.WriteLine("done {0} sec.", stw.Elapsed.TotalSeconds); } //double condNo = LaplaceMtx.condest(BatchmodeConnector.Flavor.Octave); //Console.WriteLine("condition number: {0:0.####E-00} ",condNo); } }