/// <summary>
/// Includes assembly of the matrix.
/// </summary>
/// <param name="L"></param>
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) {
using (FuncTrace tr = new FuncTrace()) {
// create operator
// ===============
{
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, ((GridData)(this.GridData)).Cells.cj, PoissonBcMap);
LapaceIp.EquationComponents["T"].Add(flux);
LapaceIp.Commit();
}
//double condNo = LaplaceMtx.condest(BatchmodeConnector.Flavor.Octave);
//Console.WriteLine("condition number: {0:0.####E-00} ",condNo);
}
}
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>
/// Spatial Operators and Matrices
/// </summary>
/// with
/// <param name="bcMap">Boundary Conditions</param>
public SpatialOperator CreateAdvectionSpatialOperator(IncompressibleBoundaryCondMap bcMap)
{
Func <int[], int[], int[], int> QuadOrderFunction = QuadOrderFunc.SumOfMaxDegrees();
string[] parameterList;
parameterList = ArrayTools.Cat(VariableNames.Velocity0Vector(D),
VariableNames.Velocity0MeanVector(D));
if (!divUzero)
{
parameterList = ArrayTools.Cat(parameterList, "div(U)");
}
SpatialOperator SO = new SpatialOperator(new string[] { "LevelSet" },
parameterList,
new string[] { "Phi-Evo" },
QuadOrderFunc.NonLinear(2));
//div(u.phi)
//SO.EquationComponents["Phi-Evo"].Add(new LevelSetUpwindFlux(GridDat, bcMap));
SO.EquationComponents["Phi-Evo"].Add(new LevelSetLLFFlux(GridDat, bcMap));
//bcMap.PhysMode = PhysicsMode.Multiphase;
//SO.EquationComponents["Phi-Evo"].Add(new LinearizedScalarConvection(D, bcMap,null));
//SO.EquationComponents["Phi-Evo"].Add(new LevelSetAdvectionCentralFlux(D));
//-phi*div(u)
if (!divUzero)
{
SO.EquationComponents["Phi-Evo"].Add(new FextSource());
}
//penalization
//Lsevo.EquationComponents["Phi-Evo"].Add(new JumpPenalization.GradientJumpForm2());
SO.Commit();
return(SO);
}
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L)
{
Op = new XSpatialOperator(1, 0, 1, QuadOrderFunc.SumOfMaxDegrees(RoundUp: true), "u", "c1");
Op.EquationComponents["c1"].Add(new DxFlux()); // Flux in Bulk Phase;
Op.EquationComponents["c1"].Add(new LevSetFlx_phi0(this.LsTrk)); // flux am lev-set 0
Op.EquationComponents["c1"].Add(new LevSetFlx_phi1(this.LsTrk)); // flux am lev-set 1
Op.Commit();
}
SpatialOperator CreateAdvectionSpatialOperator(IncompressibleBoundaryCondMap bcMap)
{
Func <int[], int[], int[], int> QuadOrderFunction = QuadOrderFunc.SumOfMaxDegrees();
string[] parameterList;
parameterList = ArrayTools.Cat(
VariableNames.Velocity0Vector(D),
VariableNames.Velocity0MeanVector(D),
"div(U)");
SpatialOperator SO = new SpatialOperator(new string[] { "LevelSet" },
parameterList,
new string[] { "Phi-Evo" },
QuadOrderFunc.NonLinear(2));
//div(u*phi)
SO.EquationComponents["Phi-Evo"].Add(new LevelSetLLFFlux(GridDat, bcMap));
//-phi*div(u)
SO.EquationComponents["Phi-Evo"].Add(new FextSource());
SO.Commit();
return(SO);
}
/// <summary>
/// Includes assembly of the matrix.
/// </summary>
/// <param name="L"></param>
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L)
{
using (FuncTrace tr = new FuncTrace()) {
// create operator
// ===============
{
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");
MultidimensionalArray LengthScales;
if (this.GridData is GridData)
{
LengthScales = ((GridData)GridData).Cells.cj;
}
else if (this.GridData is AggregationGridData)
{
LengthScales = ((AggregationGridData)GridData).AncestorGrid.Cells.cj;
}
else
{
throw new NotImplementedException();
}
var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, LengthScales, PoissonBcMap);
LapaceIp.EquationComponents["T"].Add(flux);
LapaceIp.Commit();
}
}
}
protected override void CreateEquationsAndSolvers(LoadbalData L)
{
Op = new XSpatialOperator(1, 0, 1, QuadOrderFunc.SumOfMaxDegrees(RoundUp: true), "u", "c1");
var blkFlux = new DxFlux(this.LsTrk, Control.alpha_A, Control.alpha_B);
Op.EquationComponents["c1"].Add(blkFlux); // Flux in Bulk Phase;
Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, Control.alpha_A, Control.alpha_B)); // flux am lev-set 0
Op.OnIntegratingBulk += blkFlux.NowIntegratingBulk;
Op.Commit();
if (L == null)
{
TimeIntegration = new XdgBDFTimestepping(
new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk,
true,
DelComputeOperatorMatrix, DelUpdateLevelset, DelUpdateCutCellMetrics,
3, // BDF3
//-1, // Crank-Nicolson
//0, // Explicit Euler
LevelSetHandling.LieSplitting,
MassMatrixShapeandDependence.IsTimeDependent,
SpatialOperatorType.LinearTimeDependent,
MassScale,
MultigridOperatorConfig,
this.MultigridSequence,
this.THRESHOLD,
true);
}
else
{
Debug.Assert(object.ReferenceEquals(this.MultigridSequence[0].ParentGrid, this.GridData));
TimeIntegration.DataRestoreAfterBalancing(L, new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk, this.MultigridSequence);
}
}
public XDGTestSetup(
int p,
double AggregationThreshold,
int TrackerWidth,
MultigridOperator.Mode mumo,
XQuadFactoryHelper.MomentFittingVariants momentFittingVariant,
ScalarFunction LevSetFunc = null)
{
// Level set, tracker and XDG basis
// ================================
if (LevSetFunc == null)
{
LevSetFunc = ((_2D)((x, y) => 0.8 * 0.8 - x * x - y * y)).Vectorize();
}
LevSet = new LevelSet(new Basis(grid, 2), "LevelSet");
LevSet.Clear();
LevSet.ProjectField(LevSetFunc);
LsTrk = new LevelSetTracker(grid, XQuadFactoryHelper.MomentFittingVariants.Classic, TrackerWidth, new string[] { "A", "B" }, LevSet);
LsTrk.UpdateTracker();
XB = new XDGBasis(LsTrk, p);
XSpatialOperator Dummy = new XSpatialOperator(1, 0, 1, QuadOrderFunc.SumOfMaxDegrees(RoundUp: true), "C1", "u");
//Dummy.EquationComponents["c1"].Add(new
Dummy.Commit();
//Tecplot.PlotFields(new DGField[] { LevSet }, "agglo", 0.0, 3);
// operator
// ========
Debug.Assert(p <= 4);
XDGBasis opXB = new XDGBasis(LsTrk, 4); // we want to have a very precise quad rule
var map = new UnsetteledCoordinateMapping(opXB);
int quadOrder = Dummy.QuadOrderFunction(map.BasisS.Select(bs => bs.Degree).ToArray(), new int[0], map.BasisS.Select(bs => bs.Degree).ToArray());
//agg = new MultiphaseCellAgglomerator(new CutCellMetrics(momentFittingVariant, quadOrder, LsTrk, LsTrk.SpeciesIdS.ToArray()), AggregationThreshold, false);
agg = LsTrk.GetAgglomerator(LsTrk.SpeciesIdS.ToArray(), quadOrder, __AgglomerationTreshold: AggregationThreshold);
foreach (var S in LsTrk.SpeciesIdS)
{
Console.WriteLine("Species {0}, no. of agglomerated cells {1} ",
LsTrk.GetSpeciesName(S),
agg.GetAgglomerator(S).AggInfo.SourceCells.Count());
}
// mass matrix factory
// ===================
// Basis maxB = map.BasisS.ElementAtMax(b => b.Degree);
//MassFact = new MassMatrixFactory(maxB, agg);
MassFact = LsTrk.GetXDGSpaceMetrics(LsTrk.SpeciesIdS.ToArray(), quadOrder, 1).MassMatrixFactory;
// Test field
// ==========
// set the test field: this is a polynomial function,
// but different for each species; On this field, restriction followed by prolongation should be the identity
this.Xdg_uTest = new XDGField(this.XB, "uTest");
Dictionary <SpeciesId, double> dumia = new Dictionary <SpeciesId, double>();
int i = 2;
foreach (var Spc in LsTrk.SpeciesIdS)
{
dumia.Add(Spc, i);
i -= 1;
}
SetTestValue(Xdg_uTest, dumia);
// dummy operator matrix which fits polynomial degree p
// ====================================================
Xdg_opMtx = new BlockMsrMatrix(Xdg_uTest.Mapping, Xdg_uTest.Mapping);
Xdg_opMtx.AccEyeSp(120.0);
// XDG Aggregation BasiseS
// =======================
//XAggB = MgSeq.Select(agGrd => new XdgAggregationBasis[] { new XdgAggregationBasis(uTest.Basis, agGrd) }).ToArray();
XAggB = new XdgAggregationBasis[MgSeq.Length][];
var _XAggB = AggregationGridBasis.CreateSequence(MgSeq, Xdg_uTest.Mapping.BasisS);
for (int iLevel = 0; iLevel < XAggB.Length; iLevel++)
{
XAggB[iLevel] = new[] { (XdgAggregationBasis)(_XAggB[iLevel][0]) };
XAggB[iLevel][0].Update(agg);
}
// Multigrid Operator
// ==================
Xdg_opMtx = new BlockMsrMatrix(Xdg_uTest.Mapping, Xdg_uTest.Mapping);
Xdg_opMtx.AccEyeSp(120.0);
XdgMultigridOp = new MultigridOperator(XAggB, Xdg_uTest.Mapping,
Xdg_opMtx,
MassFact.GetMassMatrix(Xdg_uTest.Mapping, false),
new MultigridOperator.ChangeOfBasisConfig[][] {
new MultigridOperator.ChangeOfBasisConfig[] {
new MultigridOperator.ChangeOfBasisConfig()
{
VarIndex = new int[] { 0 }, mode = mumo, Degree = p
}
}
});
}
/// <summary>
/// Based on the Ideas by
/// C. Basting and D. Kuzmin,
/// “A minimization-based finite element formulation for interface-preserving level set reinitialization”,
/// Computing, vol. 95, no. 1, pp. 13–25, Dec. 2012.
/// Create Spatial Operators and build the corresponding Matrices
/// For the Left-Hand Side of the ReInitProblem
/// RHS is computed on the fly in <see cref="ReInitSingleStep"/>
/// The Bulk component is constant unless the grid changes, thus it is computed in <see cref="BuildOperators(CellQuadratureScheme)"/>.
/// The Interface component changes with its motion.
/// This component is calculated in <see cref="UpdateOperators(CellQuadratureScheme)"/>.
/// </summary>
/// <param name="LSTrck"></param>
/// <param name="Control">various parameters <paramref name="EllipticReinitControl"/></param>
/// <param name="HMFOrder">order of tghe interface quadrature</param>
public EllipticReInit(LevelSetTracker LSTrck, EllipticReInitAlgoControl Control, SinglePhaseField LevelSetForReInit = null)
{
this.Control = Control;
this.LevelSetTracker = LSTrck;
if (LevelSetForReInit == null)
{
Phi = LevelSetTracker.LevelSets[0] as SinglePhaseField;
}
else
{
Phi = LevelSetForReInit;
}
this.underrelaxation = Control.underrelaxation;
Residual = new SinglePhaseField(Phi.Basis);
OldPhi = new SinglePhaseField(Phi.Basis);
NewPhi = new SinglePhaseField(Phi.Basis);
foreach (SinglePhaseField f in new List <SinglePhaseField> {
Residual, OldPhi, NewPhi
})
{
f.Clear();
f.Acc(1.0, Phi);
}
this.D = LevelSetTracker.GridDat.SpatialDimension;
this.ConvergenceCriterion = Control.ConvergenceCriterion;
this.MaxIteration = Control.MaxIt;
double PenaltyBase = ((double)((Phi.Basis.Degree + 1) * (Phi.Basis.Degree + D))) / ((double)D);
// Choose Forms according to Upwinding or Central Fluxes
string[] paramNames;
int noOfParamFields;
IEquationComponent BulkForm;
RHSForm myRHSForm;
LevelSetGradient = new VectorField <SinglePhaseField>(D, Phi.Basis, "LevelSetGradient", SinglePhaseField.Factory);
MeanLevelSetGradient = new VectorField <SinglePhaseField>(D, new Basis(Phi.GridDat, 0), "MeanLevelSetGradient", SinglePhaseField.Factory);
if (Control.Upwinding)
{
paramNames = new string[] { "OldLevelSet", "MeanLevelSetGradient[0]", "MeanLevelSetGradient[1]" };
noOfParamFields = D;
LevelSetGradient.Clear();
LevelSetGradient.Gradient(1.0, Phi);
//LevelSetGradient.GradientByFlux(1.0, Phi);
MeanLevelSetGradient.Clear();
MeanLevelSetGradient.AccLaidBack(1.0, LevelSetGradient);
parameterFields = ArrayTools.Cat(new SinglePhaseField[] { OldPhi }, MeanLevelSetGradient.ToArray());
//throw new NotImplementedException("ToDO");
BulkForm = new EllipticReInitUpwindForm_Laplace(Control.PenaltyMultiplierFlux * PenaltyBase, LSTrck);
myRHSForm = new EllipticReInitUpwindForm_RHS(Control.PenaltyMultiplierFlux * PenaltyBase, LSTrck);
OldDirection = new double[MeanLevelSetGradient.CoordinateVector.ToArray().Length];
for (int i = 0; i < MeanLevelSetGradient.CoordinateVector.Length; i++)
{
OldDirection[i] = Math.Sign(MeanLevelSetGradient.CoordinateVector[i]);
}
NewDirection = OldDirection.CloneAs();
}
else
{
paramNames = new string[] { };
noOfParamFields = 0;
parameterFields = new SinglePhaseField[] { };
BulkForm = new CentralDifferencesLHSForm(Control.PenaltyMultiplierFlux * PenaltyBase, LSTrck.GridDat.Cells.cj);
myRHSForm = new CentralDifferencesRHSForm(Control.PenaltyMultiplierFlux * PenaltyBase, LSTrck);
}
// SIP for the bulk Phase
//this.Operator_bulk = new SpatialOperator(1, noOfParamFields, 1, QuadOrderFunc.SumOfMaxDegrees(1, RoundUp: false), variableNames);
this.Operator_bulk = BulkForm.Operator();
// Zero at the Interface
// Calculate Quadrature Order
Func <int[], int[], int[], int> InterfaceQuadOrder;
InterfaceQuadOrder = QuadOrderFunc.FixedOrder(Phi.Basis.Degree * 2 + 2);
// Generate Interface Operator
this.Operator_interface = (new EllipticReInitInterfaceForm(Control.PenaltyMultiplierInterface * PenaltyBase, LSTrck)).XOperator(new[] { "A" }, InterfaceQuadOrder);
// Nonlinear Part on the RHS
// switch for the potential functions
switch (Control.Potential)
{
case ReInitPotential.BastingDoubleWell: {
myRHSForm.DiffusionRate = ((d, b) => DiffusionRates.DoubleWell(d, b));
break;
};
case ReInitPotential.BastingSingleWell: {
myRHSForm.DiffusionRate = ((d, b) => DiffusionRates.SingleWell(d, b));
break;
};
case ReInitPotential.SingleWellNear: {
myRHSForm.DiffusionRate = ((d, b) => DiffusionRates.SingleWellNear(d, b));
break;
};
case ReInitPotential.P4DoubleWell: {
Console.WriteLine("Warning - This Option for Elliptic ReInit does not work well");
myRHSForm.DiffusionRate = ((d, b) => DiffusionRates.DoubleWellAlternative(d, b));
break;
};
case ReInitPotential.SingleWellOnCutDoubleWellElse: {
myRHSForm.DiffusionRate = ((d, b) => DiffusionRates.SingleWellOnCutDoubleWellElse(d, b));
break;
}
}
Operator_RHS = myRHSForm.Operator(QuadOrderFunc.SumOfMaxDegrees(2, RoundUp: true));
// The result of the nonlinear part on the rhs is projected on a single-phase field
RHSField = new SinglePhaseField(Phi.Basis, "RHS");
OpMatrix = new MsrMatrix(this.Phi.Mapping, this.Phi.Mapping);
OpAffine = new double[OpMatrix.RowPartitioning.LocalLength];
// Matrix and RHS for the Bulk component
OpMatrix_bulk = new MsrMatrix(this.Phi.Mapping, this.Phi.Mapping);
OpAffine_bulk = new double[OpMatrix.RowPartitioning.LocalLength];
// Matrix and RHS for the Interface Penalty
OpMatrix_interface = new MsrMatrix(this.Phi.Mapping, this.Phi.Mapping);
OpAffine_interface = new double[OpMatrix.RowPartitioning.LocalLength];
// Init Parameter Fields
OldPhi.Clear();
OldPhi.Acc(1.0, Phi);
// Compute Matrices
UpdateBulkMatrix();
}
/// <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);
}
}