protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Matrix = new MsrMatrix(Convection[0].OperatorMatrix);
Matrix.Acc(ViscTerm1[0].OperatorMatrix, 1.0);
Matrix.Acc(ViscTerm2Term3[Component, Component].AssemblyMatrix, 1.0);
return(Matrix);
}
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Src = m_Src.AssemblyMatrix;
MsrMatrix Approx = new MsrMatrix(Src.RowPartitioning, Src.ColPartition);
int i0 = Src.RowPartitioning.i0;
int LocalLength = Src.RowPartitioning.LocalLength;
double BDFfactor;
switch (m_SolverConf.Control.Algorithm)
{
case SolutionAlgorithms.Steady_SIMPLE:
BDFfactor = 0.0;
break;
case SolutionAlgorithms.Unsteady_SIMPLE:
int BDFOrder = m_SolverConf.BDFOrder;
double dt = m_SolverConf.dt;
BDFfactor = m_BDF.beta[BDFOrder - 1][0] / (m_BDF.gamma[BDFOrder - 1] * dt);
break;
default:
throw new ArgumentException();
}
switch (m_SolverConf.Control.PredictorApproximation)
{
case PredictorApproximations.Identity:
case PredictorApproximations.Identity_IP1:
Approx.AccEyeSp();
Approx.AccEyeSp(BDFfactor);
break;
case PredictorApproximations.Diagonal:
for (int row = 0; row < LocalLength; row++)
{
double Src_ii = Src[row + i0, row + i0];
double Rho_ii = m_Rho[row + i0, row + i0];
Approx[row + i0, row + i0] = BDFfactor * Rho_ii + Src_ii;
}
break;
case PredictorApproximations.BlockDiagonal:
BlockDiagonalMatrix SrcBlock = new BlockDiagonalMatrix(Src, Src.RowPartitioning.LocalLength / m_NoOfCells, Src.ColPartition.LocalLength / m_NoOfCells);
Approx.Acc(1.0, SrcBlock);
Approx.Acc(BDFfactor, m_Rho);
break;
default:
throw new ArgumentException();
}
return(Approx);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix CorrectorMatrix = new MsrMatrix(m_IPOperator.OperatorMatrix);
switch (m_SolverConf.Control.Algorithm)
{
case SolutionAlgorithms.Steady_SIMPLE:
break;
case SolutionAlgorithms.Unsteady_SIMPLE:
// gamma * dt / (beta_0 + gamma * dt)
double UnsteadyFactor = m_BDF.gamma[m_SolverConf.BDFOrder - 1] * m_SolverConf.dt / (m_BDF.beta[m_SolverConf.BDFOrder - 1][0] + m_BDF.gamma[m_SolverConf.BDFOrder - 1] * m_SolverConf.dt);
CorrectorMatrix.Scale(UnsteadyFactor);
break;
default:
throw new NotImplementedException();
}
if (m_PressureStabilization != null)
{
CorrectorMatrix.Acc(-1.0, m_PressureStabilization.OperatorMatrix);
}
CorrectorMatrix.AssumeSymmetric = true;
return(CorrectorMatrix);
}
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Approx = m_Approx.AssemblyMatrix;
MsrMatrix ApproxInv = new MsrMatrix(Approx.RowPartitioning, Approx.ColPartition);
switch (m_SolverConf.PredictorApproximation)
{
case PredictorApproximations.Identity:
case PredictorApproximations.Identity_IP1:
case PredictorApproximations.Diagonal:
int i0 = Approx.RowPartitioning.i0;
int LocalLength = Approx.RowPartitioning.LocalLength;
for (int row = 0; row < LocalLength; row++)
{
double Approx_ii = Approx[row + i0, row + i0];
ApproxInv[row + i0, row + i0] = 1.0 / Approx_ii;
}
break;
case PredictorApproximations.BlockDiagonal:
BlockDiagonalMatrix ApproxBlock = new BlockDiagonalMatrix(Approx, Approx.RowPartitioning.LocalLength / m_LocalNoOfCells, Approx.ColPartition.LocalLength / m_LocalNoOfCells);
BlockDiagonalMatrix ApproxBlockInv = ApproxBlock.Invert();
ApproxInv.Acc(1.0, ApproxBlockInv);
break;
default:
throw new ArgumentException();
}
return(ApproxInv);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Matrix = new MsrMatrix(m_Convection.OperatorMatrix);
Matrix.Acc(m_Visc.OperatorMatrix, 1.0);
return(Matrix);
}
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L)
{
using (FuncTrace tr = new FuncTrace()) {
// assemble system, create matrix
// ------------------------------
var volQrSch = new CellQuadratureScheme(true, CellMask.GetFullMask(this.GridData));
var edgQrSch = new EdgeQuadratureScheme(true, EdgeMask.GetFullMask(this.GridData));
double D = this.GridData.SpatialDimension;
double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D;
double penalty_factor = base.Control.penalty_poisson;
{
// equation assembly
// -----------------
tr.Info("creating sparse system...");
Console.WriteLine("creating sparse system for {0} DOF's ...", T.Mapping.Ntotal);
Stopwatch stw = new Stopwatch();
stw.Start();
SpatialOperator LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T");
var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, this.GridData.Cells.cj, base.Control);
LapaceIp.EquationComponents["T"].Add(flux);
LapaceIp.Commit();
#if DEBUG
var RefLaplaceMtx = new MsrMatrix(T.Mapping);
#endif
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
//int q = LaplaceMtx._GetTotalNoOfNonZeros();
//tr.Info("finished: Number of non-zeros: " + q);
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);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix Matrix = new MsrMatrix(Convection.OperatorMatrix);
Matrix.Acc(HeatConduction.OperatorMatrix, 1.0);
return(Matrix);
}
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());
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Op.GetMatrixBuilder(base.LsTrk, ProblemMapping, null, ProblemMapping, LsTrk.SpeciesIdS.ToArray());
mtxBuilder.time = 0.0;
mtxBuilder.ComputeMatrix(OperatorMatrix, Affine);
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());
mtxBuilder.ComputeMatrix(AltOperatorMatrix, Affine);
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);
}
protected override MsrMatrix DefineMatrix(double dt)
{
MsrMatrix res = new MsrMatrix(MatAsmblyTemperature.AssemblyMatrix);
if ((ModeRelaxTemperature == RelaxationTypes.Implicit) && (RelaxFactor != 0.0))
{
res.Acc(RelaxFactor, MatAsmblyTemperatureApprox.AssemblyMatrix);
}
if (BDF != null)
{
double LhsSummand = BDF.GetLhsSummand(dt, base.m_solverConf.BDFOrder);
res.Acc(LhsSummand / gamma, DensityMatrix);
}
return(res);
}
protected override MsrMatrix DefineMatrix(double dt)
{
MsrMatrix res = new MsrMatrix(m_MatAsmblyPredictor.AssemblyMatrix);
if (m_RelaxFactor != 0.0)
{
res.Acc(m_RelaxFactor, m_MatAsmblyPredictorApprox.AssemblyMatrix);
}
if (m_BDF != null)
{
double LhsSummand = m_BDF.GetLhsSummand(dt, base.m_solverConf.BDFOrder);
res.Acc(LhsSummand, m_DensityMatrix);
}
return(res);
}
/// <summary>
/// computes <see cref="LaplaceMtx"/> and <see cref="LaplaceAffine"/>
/// </summary>
private void UpdateMatrices() {
using (var tr = new FuncTrace()) {
// 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, MaskType.Geometrical));
var edgQrSch = new EdgeQuadratureScheme(true, EdgeMask.GetFullMask(this.GridData, MaskType.Geometrical));
#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);
//var JB = LapaceIp.GetFDJacobianBuilder(T.Mapping.Fields, null, T.Mapping, edgQrSch, volQrSch);
//var JacobiMtx = new BlockMsrMatrix(T.Mapping);
//var JacobiAffine = new double[T.Mapping.LocalLength];
//JB.ComputeMatrix(JacobiMtx, JacobiAffine);
//double L2ErrAffine = GenericBlas.L2Dist(JacobiAffine, LaplaceAffine);
//var ErrMtx2 = LaplaceMtx.CloneAs();
//ErrMtx2.Acc(-1.0, JacobiMtx);
//double LinfErrMtx2 = ErrMtx2.InfNorm();
//JacobiMtx.SaveToTextFileSparse("D:\\tmp\\Jac.txt");
//LaplaceMtx.SaveToTextFileSparse("D:\\tmp\\Lap.txt");
//Console.WriteLine("FD Jacobi Mtx: {0:e14}, Affine: {1:e14}", LinfErrMtx2, L2ErrAffine);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix CorrectorMatrix = new MsrMatrix(m_DivergenceConti[0].LocalLength);
for (int comp = 0; comp < m_DivergenceConti.Length; comp++)
{
MsrMatrix prod1 = MsrMatrix.Multiply(m_PredictorApproxInv.AssemblyMatrix, m_PressureGradient[comp].OperatorMatrix);
MsrMatrix prod2 = MsrMatrix.Multiply(m_DivergenceConti[comp].OperatorMatrix, prod1);
CorrectorMatrix.Acc(1.0, prod2);
}
if (m_PressureStabilization != null)
{
CorrectorMatrix.Acc(-1.0, m_PressureStabilization.OperatorMatrix);
}
//CorrectorMatrix.AssumeSymmetric = true;
return(CorrectorMatrix);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override MsrMatrix ComputeMatrix()
{
MsrMatrix CorrectorMatrix = new MsrMatrix(m_VelocityDivergence[0].LocalLength);
for (int comp = 0; comp < m_VelocityDivergence.Length; comp++)
{
MsrMatrix prod1 = MsrMatrix.Multiply(m_PredictorApproxInv[comp].AssemblyMatrix, m_PressureGradient[comp].OperatorMatrix);
MsrMatrix prod2 = MsrMatrix.Multiply(m_VelocityDivergence[comp].OperatorMatrix, prod1);
CorrectorMatrix.Acc(1.0, prod2);
}
//CorrectorMatrix.AssumeSymmetric = false;
return(CorrectorMatrix);
}
protected override MsrMatrix DefineMatrix(double dt)
{
MsrMatrix res = new MsrMatrix(m_MatAsmblyLevelSet.AssemblyMatrix);
if ((m_ModeRelaxLevelSet == RelaxationTypes.Implicit) && (m_RelaxFactor != 0.0))
{
res.Acc(m_RelaxFactor, m_MatAsmblyLevelSetApprox.AssemblyMatrix);
}
if (m_BDF != null)
{
double LhsSummand = m_BDF.GetLhsSummand(dt, m_solverConf.BDFOrder);
res.AccEyeSp(LhsSummand);
}
return(res);
}
/// <summary>
///
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
protected override MsrMatrix DefineMatrix(double dt)
{
MsrMatrix res = new MsrMatrix(m_MatAsmblyPredictor[0].AssemblyMatrix);
//See left-hand side of Eq. (18) in
//B. Klein, F. Kummer, M. Keil, and M. Oberlack,
//An extension of the SIMPLE based discontinuous Galerkin solver to unsteady incompressible flows, J. Comput. Phys., 2013.
if (m_RelaxFactor != 0.0)
{
res.Acc(m_RelaxFactor, m_MatAsmblyPredictorApprox.AssemblyMatrix);
}
if (m_BDF != null)
{
double LhsSummand = m_BDF.GetLhsSummand(dt, base.m_solverConf.BDFOrder);
res.AccEyeSp(LhsSummand);
}
return(res);
}
// Local Variables for Iteration
// <summary>
// Counter for Iteration Steps
// </summary>
//double OldResidual = double.MaxValue;
//int divergencecounter = 0;
///// <summary>
///// Checks for Reaching Max. Number of Iterations and Divergence of Algorithm
///// </summary>
///// <param name="Residual">Change Rate of the Algorithm</param>
///// <returns>Reaching Max Iterations, Aborts when diverged</returns>
//public bool CheckAbortCriteria(double Residual, int IterationCounter) {
// if (Residual <= ConvergenceCriterion) {
// Console.WriteLine("EllipticReInit converged after {0} Iterations ", IterationCounter);
// return true;
// }
// if (Residual >= OldResidual) divergencecounter++;
// else divergencecounter = 0;
// if (IterationCounter >= MaxIteration) {
// Console.WriteLine("Elliptic Reinit Max Iterations Reached");
// return true;
// };
// if (divergencecounter > MaxIteration / 2) {
// Console.WriteLine("Elliptic Reinit diverged - Aborting");
// throw new ApplicationException();
// }
// OldResidual = Residual;
// IterationCounter++;
// return false;
//}
//bool PreviouslyOnSubgrid = false;
/// <summary>
/// Updates the Operator Matrix after level-set motion
/// </summary>
/// <param name="Restriction">
/// The subgrid, on which the ReInit is performed
/// </param>
/// <param name="IncludingInterface">
/// !! Not yet functional !!
/// True, if the subgrid contains the interface, this causes all external edges of the subgrid to be treated as boundaries
/// False, for the rest of the domain, thus the flux to the adjacent cells wil be evaluated
/// </param>
public void UpdateOperators(SubGrid Restriction = null, bool IncludingInterface = true)
{
if (!IncludingInterface)
{
throw new NotImplementedException("Untested, not yet functional!");
}
using (new FuncTrace()) {
//using (var slv = new ilPSP.LinSolvers.MUMPS.MUMPSSolver()) {
//using (var slv = new ilPSP.LinSolvers.PARDISO.PARDISOSolver()) {
//using (var slv = new ilPSP.LinSolvers.HYPRE.GMRES()) {
if (Control.Upwinding)
{
OldPhi.Clear();
OldPhi.Acc(1.0, Phi);
//Calculate
LevelSetGradient.Clear();
LevelSetGradient.Gradient(1.0, Phi, Restriction?.VolumeMask);
//LevelSetGradient.Gradient(1.0, Phi);
//LevelSetGradient.GradientByFlux(1.0, Phi);
MeanLevelSetGradient.Clear();
MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient, Restriction?.VolumeMask);
//MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient);
}
if (slv != null)
{
slv.Dispose();
}
slv = Control.solverFactory();
OpMatrix_interface.Clear();
OpAffine_interface.Clear();
// Build the Quadrature-Scheme for the interface operator
// Note: The HMF-Quadrature over a surface is formally a volume quadrature, since it uses the volume quadrature nodes.
//XSpatialOperatorExtensions.ComputeMatrixEx(Operator_interface,
////Operator_interface.ComputeMatrixEx(
// LevelSetTracker,
// Phi.Mapping,
// null,
// Phi.Mapping,
// OpMatrix_interface,
// OpAffine_interface,
// false,
// 0,
// false,
// subGrid:Restriction,
// whichSpc: LevelSetTracker.GetSpeciesId("A")
// );
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Operator_interface.GetMatrixBuilder(LevelSetTracker, Phi.Mapping, null, Phi.Mapping);
MultiphaseCellAgglomerator dummy = LevelSetTracker.GetAgglomerator(LevelSetTracker.SpeciesIdS.ToArray(), Phi.Basis.Degree * 2 + 2, 0.0);
//mtxBuilder.SpeciesOperatorCoefficients[LevelSetTracker.GetSpeciesId("A")].CellLengthScales = dummy.CellLengthScales[LevelSetTracker.GetSpeciesId("A")];
mtxBuilder.CellLengthScales.Add(LevelSetTracker.GetSpeciesId("A"), dummy.CellLengthScales[LevelSetTracker.GetSpeciesId("A")]);
mtxBuilder.time = 0;
mtxBuilder.MPITtransceive = false;
mtxBuilder.ComputeMatrix(OpMatrix_interface, OpAffine_interface);
// Regenerate OpMatrix for subgrid -> adjacent cells must be trated as boundary
if (Restriction != null)
{
OpMatrix_bulk.Clear();
OpAffine_bulk.Clear();
//Operator_bulk.ComputeMatrix(
// Phi.Mapping,
// parameterFields,
// Phi.Mapping,
// OpMatrix_bulk, OpAffine_bulk,
// OnlyAffine: false, sgrd: Restriction);
EdgeQuadratureScheme edgescheme;
//if (Control.Upwinding) {
// edgescheme = new EdgeQuadratureScheme(true, IncludingInterface ? Restriction.AllEdgesMask : null);
//}
//else {
edgescheme = new EdgeQuadratureScheme(true, IncludingInterface ? Restriction.InnerEdgesMask : null);
//}
Operator_bulk.ComputeMatrixEx(Phi.Mapping,
parameterFields,
Phi.Mapping, OpMatrix_bulk, OpAffine_bulk, false, 0,
edgeQuadScheme: edgescheme,
volQuadScheme: new CellQuadratureScheme(true, IncludingInterface ? Restriction.VolumeMask : null)
);
//PreviouslyOnSubgrid = true;
}
// recalculate full Matrix
//else if (PreviouslyOnSubgrid) {
else
{
OpMatrix_bulk.Clear();
OpAffine_bulk.Clear();
Operator_bulk.ComputeMatrixEx(Phi.Mapping,
parameterFields,
Phi.Mapping, OpMatrix_bulk, OpAffine_bulk, false, 0
);
//PreviouslyOnSubgrid = false;
}
/// Compose the Matrix
/// This is symmetric due to the symmetry of the SIP and the penalty term
OpMatrix.Clear();
OpMatrix.Acc(1.0, OpMatrix_bulk);
OpMatrix.Acc(1.0, OpMatrix_interface);
OpMatrix.AssumeSymmetric = !Control.Upwinding;
//OpMatrix.AssumeSymmetric = false;
/// Compose the RHS of the above operators. (-> Boundary Conditions)
/// This does NOT include the Nonlinear RHS, which will be added later
OpAffine.Clear();
OpAffine.AccV(1.0, OpAffine_bulk);
OpAffine.AccV(1.0, OpAffine_interface);
#if Debug
ilPSP.Connectors.Matlab.BatchmodeConnector matlabConnector;
matlabConnector = new BatchmodeConnector();
#endif
if (Restriction != null)
{
SubVecIdx = Phi.Mapping.GetSubvectorIndices(Restriction, true, new int[] { 0 });
int L = SubVecIdx.Length;
SubMatrix = new MsrMatrix(L);
SubRHS = new double[L];
SubSolution = new double[L];
OpMatrix.AccSubMatrixTo(1.0, SubMatrix, SubVecIdx, default(int[]), SubVecIdx, default(int[]));
slv.DefineMatrix(SubMatrix);
#if Debug
Console.WriteLine("ConditionNumber of ReInit-Matrix is " + SubMatrix.condest().ToString("E"));
#endif
}
else
{
slv.DefineMatrix(OpMatrix);
#if Debug
Console.WriteLine("ConditionNumber of ReInit-Matrix is " + OpMatrix.condest().ToString("E"));
#endif
}
}
}
/// <summary>
/// Create Spatial Operators and build the corresponding Matrices
/// </summary>
public void ComputeMatrices(IList <DGField> InterfaceParams, bool nearfield)
{
OpMatrix = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_bulk = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_bulk = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_interface = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_interface = new double[OpMatrix.RowPartitioning.LocalLength];
//LevelSetTracker.GetLevelSetGradients(0,);
// bulk part of the matrix
//Operator_bulk.ComputeMatrix(
// Extension.Mapping,
// LevelSetGradient.ToArray(),
// Extension.Mapping,
// OpMatrix_bulk, OpAffine_bulk,
// OnlyAffine: false, sgrd: null);
switch (Control.FluxVariant)
{
case FluxVariant.GradientBased:
// Flux Direction based on Mean Level Set Gradient
BulkParams = new List <DGField> {
}; // Hack, to make ArrayTools.Cat produce a List of DGFields
// second Hack: Does only work, when InterfaceParams is according to a single component flux,
// else, we will have to change the boundary edge flux
BulkParams = ArrayTools.Cat(BulkParams, LevelSetGradient.ToArray(), Phi, MeanLevelSetGradient.ToArray(), InterfaceParams.ToArray());
MeanLevelSetGradient.Clear();
MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient);
break;
case FluxVariant.ValueBased:
// Flux Direction Based on Cell-Averaged Level-Set Value
BulkParams = ArrayTools.Cat(LevelSetGradient.ToArray(), Phi, MeanLevelSet);
MeanLevelSet.Clear();
MeanLevelSet.AccLaidBack(1.0, Phi);
break;
case FluxVariant.SWIP:
BulkParams = LevelSetGradient.ToArray();
break;
default:
throw new Exception();
}
// Build Operator
Operator_bulk.ComputeMatrixEx(Extension.Mapping,
BulkParams,
Extension.Mapping,
OpMatrix_bulk, OpAffine_bulk,
OnlyAffine: false,
time: 0.0,
edgeQuadScheme: new EdgeQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).InnerEdgesMask : null),
volQuadScheme: new CellQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).VolumeMask : null)
);
Operator_interface.ComputeMatrixEx(
LevelSetTracker,
Extension.Mapping,
InterfaceParams,
Extension.Mapping,
OpMatrix_interface,
OpAffine_interface,
OnlyAffine: false,
time: 0,
MPIParameterExchange: false,
whichSpc: LevelSetTracker.GetSpeciesId("A")
);
#if DEBUG
OpMatrix_bulk.CheckForNanOrInfM();
OpAffine_bulk.CheckForNanOrInfV();
OpMatrix_interface.CheckForNanOrInfM();
OpAffine_interface.CheckForNanOrInfV();
#endif
//Only for Debugging purposes
//OpMatrix.SaveToTextFileSparse("C:\\tmp\\EllipticReInit.txt");
Debug.Assert(OpMatrix_interface.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of InterfaceOperator is 0");
Debug.Assert(OpMatrix_bulk.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of BulkOperator is 0");
#if DEBUG
//Console.WriteLine( "L2-Norm of Diagonal of InterfaceOperator is {0}", OpMatrix_interface.GetDiagVector().L2Norm() );
#endif
OpMatrix.Clear();
OpMatrix.Acc(1.0, OpMatrix_bulk);
OpMatrix.Acc(1.0, OpMatrix_interface);
//Console.WriteLine("Op-Matrix Symmetry-Deviation: {0}", OpMatrix.SymmetryDeviation());
OpMatrix.AssumeSymmetric = false;
OpAffine.Clear();
OpAffine.AccV(1.0, OpAffine_bulk);
OpAffine.AccV(1.0, OpAffine_interface);
#if DEBUG
//Console.WriteLine("Condition Number of Extension Operator {0}", OpMatrix.condest());
#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);
}
}
/// <summary>
/// Create Spatial Operators and build the corresponding Matrices
/// </summary>
public void ComputeMatrices(IList <DGField> InterfaceParams, bool nearfield)
{
OpMatrix = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_bulk = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_bulk = new double[OpMatrix.RowPartitioning.LocalLength];
OpMatrix_interface = new MsrMatrix(this.Extension.Mapping, this.Extension.Mapping);
OpAffine_interface = new double[OpMatrix.RowPartitioning.LocalLength];
//LevelSetTracker.GetLevelSetGradients(0,);
// bulk part of the matrix
//Operator_bulk.ComputeMatrix(
// Extension.Mapping,
// LevelSetGradient.ToArray(),
// Extension.Mapping,
// OpMatrix_bulk, OpAffine_bulk,
// OnlyAffine: false, sgrd: null);
switch (Control.FluxVariant)
{
case FluxVariant.GradientBased:
// Flux Direction based on Mean Level Set Gradient
BulkParams = new List <DGField> {
}; // Hack, to make ArrayTools.Cat produce a List of DGFields
// second Hack: Does only work, when InterfaceParams is according to a single component flux,
// else, we will have to change the boundary edge flux
BulkParams = ArrayTools.Cat(BulkParams, LevelSetGradient.ToArray(), Phi, MeanLevelSetGradient.ToArray(), InterfaceParams.ToArray());
MeanLevelSetGradient.Clear();
MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient);
break;
case FluxVariant.ValueBased:
// Flux Direction Based on Cell-Averaged Level-Set Value
BulkParams = ArrayTools.Cat(LevelSetGradient.ToArray(), Phi, MeanLevelSet);
MeanLevelSet.Clear();
MeanLevelSet.AccLaidBack(1.0, Phi);
break;
case FluxVariant.SWIP:
BulkParams = LevelSetGradient.ToArray();
break;
default:
throw new Exception();
}
// Build Operator
Operator_bulk.ComputeMatrixEx(Extension.Mapping,
BulkParams,
Extension.Mapping,
OpMatrix_bulk, OpAffine_bulk,
OnlyAffine: false,
time: 0.0,
edgeQuadScheme: new EdgeQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).InnerEdgesMask : null),
volQuadScheme: new CellQuadratureScheme(true, nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1).VolumeMask : null)
);
//Operator_interface.ComputeMatrixEx(
// LevelSetTracker,
// Extension.Mapping,
// InterfaceParams,
// Extension.Mapping,
// OpMatrix_interface,
// OpAffine_interface,
// OnlyAffine: false,
// time: 0,
// MPIParameterExchange: false,
// whichSpc: LevelSetTracker.GetSpeciesId("A")
// );
Operator_interface.OperatorCoefficientsProvider =
delegate(LevelSetTracker lstrk, SpeciesId spc, int quadOrder, int TrackerHistoryIdx, double time) {
var r = new CoefficientSet()
{
};
//throw new NotImplementedException("todo");
return(r);
};
XSpatialOperatorMk2.XEvaluatorLinear mtxBuilder = Operator_interface.GetMatrixBuilder(LevelSetTracker,
Extension.Mapping, InterfaceParams, Extension.Mapping);
MultiphaseCellAgglomerator dummy = LevelSetTracker.GetAgglomerator(LevelSetTracker.SpeciesIdS.ToArray(), 2 * Extension.Basis.Degree + 2, 0.0);
mtxBuilder.CellLengthScales.Add(LevelSetTracker.GetSpeciesId("A"), dummy.CellLengthScales[LevelSetTracker.GetSpeciesId("A")]);
mtxBuilder.time = 0;
mtxBuilder.MPITtransceive = false;
mtxBuilder.ComputeMatrix(OpMatrix_interface, OpAffine_interface);
#if DEBUG
OpMatrix_bulk.CheckForNanOrInfM();
OpAffine_bulk.CheckForNanOrInfV();
OpMatrix_interface.CheckForNanOrInfM();
OpAffine_interface.CheckForNanOrInfV();
#endif
//Only for Debugging purposes
Debug.Assert(OpMatrix_interface.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of InterfaceOperator is 0");
Debug.Assert(OpMatrix_bulk.GetDiagVector().L2Norm() > 0, "L2-Norm of Diagonal of BulkOperator is 0");
#if DEBUG
//Console.WriteLine( "L2-Norm of Diagonal of InterfaceOperator is {0}", OpMatrix_interface.GetDiagVector().L2Norm() );
#endif
OpMatrix.Clear();
OpMatrix.Acc(1.0, OpMatrix_bulk);
OpMatrix.Acc(1.0, OpMatrix_interface);
//Console.WriteLine("Op-Matrix Symmetry-Deviation: {0}", OpMatrix.SymmetryDeviation());
OpMatrix.AssumeSymmetric = false;
OpAffine.Clear();
OpAffine.AccV(1.0, OpAffine_bulk);
OpAffine.AccV(1.0, OpAffine_interface);
#if DEBUG
//Console.WriteLine("Condition Number of Extension Operator {0}", OpMatrix.condest());
#endif
}
