/// <summary>
/// Create Spatial Operators and build the corresponding Matrices
/// </summary>
public void UpdateRHS(SinglePhaseField Extension, SinglePhaseField InterfaceValue, bool nearfield)
{
this.Extension = Extension;
OpAffine.Clear();
XSpatialOperatorExtensions.ComputeMatrixEx(Operator_interface,
//Operator_interface.ComputeMatrixEx(
LevelSetTracker,
Extension.Mapping,
new List <DGField> {
InterfaceValue
},
Extension.Mapping,
OpMatrix_interface,
OpAffine_interface,
OnlyAffine: true,
time: 0,
MPIParameterExchange: false,
whichSpc: LevelSetTracker.GetSpeciesId("A"),
subGrid: nearfield ? LevelSetTracker.Regions.GetNearFieldSubgrid(1) : null
);
if (OpAffine.L2Norm() == 0)
{
Console.WriteLine("RHS of Bulk equation is empty as expected.");
}
OpAffine.Clear();
OpAffine.AccV(1.0, OpAffine_bulk);
OpAffine.AccV(1.0, OpAffine_interface);
}
// 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")
);
// 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
}
}
}
