/// <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);
}
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>
/// Obtaining the time integrated spatial discretization of the reinitialization equation in a narrow band around the zero level set, based on a Godunov's numerical Hamiltonian calculation
/// </summary>
/// <param name="LS"> The level set function </param>
/// <param name="Restriction"> The narrow band around the zero level set </param>
/// <param name="NumberOfTimesteps">
/// maximum number of pseudo-timesteps
/// </param>
/// <param name="thickness">
/// The smoothing width of the signum function.
/// This is the main stabilization parameter for re-initialization.
/// It should be set to approximately 3 cells.
/// </param>
/// <param name="TimestepSize">
/// size of the pseudo-timestep
/// </param>
public void ReInitialize(LevelSet LS, SubGrid Restriction, double thickness, double TimestepSize, int NumberOfTimesteps)
{
using (var tr = new FuncTrace()) {
// log parameters:
tr.Info("thickness: " + thickness.ToString(NumberFormatInfo.InvariantInfo));
tr.Info("TimestepSize: " + TimestepSize.ToString(NumberFormatInfo.InvariantInfo));
tr.Info("NumberOfTimesteps: " + NumberOfTimesteps);
ExplicitEuler TimeIntegrator;
SpatialOperator SO;
Func <int[], int[], int[], int> QuadratureOrder = QuadOrderFunc.NonLinear(3);
if (m_ctx.SpatialDimension == 2)
{
SO = new SpatialOperator(1, 5, 1, QuadratureOrder, new string[] { "LS", "LSCGV", "LSDG[0]", "LSUG[0]", "LSDG[1]", "LSUG[1]", "Result" });
SO.EquationComponents["Result"].Add(new GodunovHamiltonian(m_ctx, thickness));
SO.Commit();
TimeIntegrator = new RungeKutta(m_Scheme, SO, new CoordinateMapping(LS), new CoordinateMapping(LSCGV, LSDG[0], LSUG[0], LSDG[1], LSUG[1]), sgrd: Restriction);
}
else
{
SO = new SpatialOperator(1, 7, 1, QuadratureOrder, new string[] { "LS", "LSCGV", "LSDG[0]", "LSUG[0]", "LSDG[1]", "LSUG[1]", "LSDG[2]", "LSUG[2]", "Result" });
SO.EquationComponents["Result"].Add(new GodunovHamiltonian(m_ctx, thickness));
SO.Commit();
TimeIntegrator = new RungeKutta(m_Scheme, SO, new CoordinateMapping(LS), new CoordinateMapping(LSCGV, LSDG[0], LSUG[0], LSDG[1], LSUG[1], LSDG[2], LSUG[2]), sgrd: Restriction);
}
// Calculating the gradients in each sub-stage of a Runge-Kutta integration procedure
ExplicitEuler.ChangeRateCallback EvalGradients = delegate(double t1, double t2) {
LSUG.Clear();
CalculateLevelSetGradient(LS, LSUG, "Upwind", Restriction);
LSDG.Clear();
CalculateLevelSetGradient(LS, LSDG, "Downwind", Restriction);
LSCG.Clear();
CalculateLevelSetGradient(LS, LSCG, "Central", Restriction);
LSCGV.Clear();
var VolMask = (Restriction != null) ? Restriction.VolumeMask : null;
LSCGV.ProjectAbs(1.0, VolMask, LSCG.ToArray());
};
TimeIntegrator.OnBeforeComputeChangeRate += EvalGradients;
{
EvalGradients(0, 0);
var GodunovResi = new SinglePhaseField(LS.Basis, "Residual");
SO.Evaluate(1.0, 0.0, LS.Mapping, TimeIntegrator.ParameterMapping.Fields, GodunovResi.Mapping, Restriction);
//Tecplot.Tecplot.PlotFields(ArrayTools.Cat<DGField>( LSUG, LSDG, LS, GodunovResi), "Residual", 0, 3);
}
// pseudo-timestepping
// ===================
double factor = 1.0;
double time = 0;
LevelSet prevLevSet = new LevelSet(LS.Basis, "prevLevSet");
CellMask RestrictionMask = (Restriction == null) ? null : Restriction.VolumeMask;
for (int i = 0; (i < NumberOfTimesteps); i++)
{
tr.Info("Level set reinitialization pseudo-timestepping, timestep " + i);
// backup old Levelset
// -------------------
prevLevSet.Clear();
prevLevSet.Acc(1.0, LS, RestrictionMask);
// time integration
// ----------------
double dt = TimestepSize * factor;
tr.Info("dt = " + dt.ToString(NumberFormatInfo.InvariantInfo) + " (factor = " + factor.ToString(NumberFormatInfo.InvariantInfo) + ")");
TimeIntegrator.Perform(dt);
time += dt;
// change norm
// ------
prevLevSet.Acc(-1.0, LS, RestrictionMask);
double ChangeNorm = prevLevSet.L2Norm(RestrictionMask);
Console.WriteLine("Reinit: PseudoTime: {0} - Changenorm: {1}", i, ChangeNorm);
//Tecplot.Tecplot.PlotFields(new SinglePhaseField[] { LS }, m_ctx, "Reinit-" + i, "Reinit-" + i, i, 3);
}
//*/
}
}
/// <summary>
///
/// </summary>
/// <param name="jCell"></param>
/// <param name="AcceptedMask"></param>
/// <param name="Phi"></param>
/// <param name="gradPhi"></param>
/// <param name="__DiffusionCoeff">Output: if artificial diffusion is turned</param>
/// <param name="MaxAllowedPhi">Input: upper threshold for the values of <paramref name="Phi"/> in cell <see cref="jCell"/>.</param>
/// <param name="MinAllowedPhi">Input: lower threshold for the values of <paramref name="Phi"/> in cell <see cref="jCell"/>.</param>
/// <returns></returns>
public bool LocalSolve_Iterative(int jCell, BitArray AcceptedMask, SinglePhaseField Phi, VectorField <SinglePhaseField> gradPhi, SinglePhaseField __DiffusionCoeff, double MaxAllowedPhi, double MinAllowedPhi)
{
//this.LocalSolve_Geometric(jCell, AcceptedMask, Phi, +1, out MinAllowedPhi, out MaxAllowedPhi);) {
int N = this.LevelSetBasis.GetLength(jCell);
int i0G = this.LevelSetMapping.GlobalUniqueCoordinateIndex(0, jCell, 0);
int i0L = this.LevelSetMapping.LocalUniqueCoordinateIndex(0, jCell, 0);
SinglePhaseField __AcceptedMask = new SinglePhaseField(new Basis(this.GridDat, 0), "accepted");
for (int j = 0; j < AcceptedMask.Length; j++)
{
__AcceptedMask.SetMeanValue(j, AcceptedMask[j] ? 1.0 : 0.0);
}
// subgrid on which we are working, consisting only of one cell
SubGrid jCellGrid = new SubGrid(new CellMask(this.GridDat, Chunk.GetSingleElementChunk(jCell)));
// create spatial operator
IEvaluatorNonLin evo;
{
SpatialOperator op = new SpatialOperator(1, 2, 1, QuadOrderFunc.NonLinear(2), "Phi", "dPhi_dx0", "dPhi_dx1", "cod1");
op.EquationComponents["cod1"].Add(new ReinitOperator());
op.EdgeQuadraturSchemeProvider = g => (new EdgeQuadratureScheme(domain: EdgeMask.GetEmptyMask(g)));
op.VolumeQuadraturSchemeProvider = g => (new CellQuadratureScheme(domain: jCellGrid.VolumeMask));
op.Commit();
evo = op.GetEvaluatorEx(Phi.Mapping.Fields, gradPhi.Mapping.Fields, Phi.Mapping);
evo.ActivateSubgridBoundary(jCellGrid.VolumeMask, subGridBoundaryTreatment: SubGridBoundaryModes.InnerEdge);
}
// create artificial diffusion operator
MultidimensionalArray DiffMtx;
double[] DiffRhs;
SpatialOperator dop;
{
double penaltyBase = this.LevelSetBasis.Degree + 2;
penaltyBase = penaltyBase.Pow2();
dop = (new ArtificialViscosity(AcceptedMask, penaltyBase, GridDat.Cells.h_min, jCell, -1.0)).Operator(1);
MsrMatrix _DiffMtx = new MsrMatrix(this.LevelSetMapping, this.LevelSetMapping);
double[] _DiffRhs = new double[this.LevelSetMapping.LocalLength];
dop.ComputeMatrixEx(this.LevelSetMapping, new DGField[] { Phi, null, null }, this.LevelSetMapping,
_DiffMtx, _DiffRhs, OnlyAffine: false,
edgeQuadScheme: (new EdgeQuadratureScheme(domain: jCellGrid.AllEdgesMask)),
volQuadScheme: (new CellQuadratureScheme(domain: jCellGrid.VolumeMask)));
// extract matrix for 'jCell'
DiffMtx = MultidimensionalArray.Create(N, N);
DiffRhs = new double[N];
for (int n = 0; n < N; n++)
{
#if DEBUG
int Lr;
int[] row_cols = null;
double[] row_vals = null;
Lr = _DiffMtx.GetRow(i0G + n, ref row_cols, ref row_vals);
for (int lr = 0; lr < Lr; lr++)
{
int ColIndex = row_cols[lr];
double Value = row_vals[lr];
Debug.Assert((ColIndex >= i0G && ColIndex < i0G + N) || (Value == 0.0), "Matrix is expected to be block-diagonal.");
}
#endif
for (int m = 0; m < N; m++)
{
DiffMtx[n, m] = _DiffMtx[i0G + n, i0G + m];
}
DiffRhs[n] = _DiffRhs[i0L + n];
}
#if DEBUG
var Test = DiffMtx.Transpose();
Test.Acc(-1.0, DiffMtx);
Debug.Assert(Test.InfNorm() <= 1.0e-8);
#endif
}
// find 'good' initial value by geometric solve AND
// thresholds for the maximum an minimal value of Phi
double Range = MaxAllowedPhi - MinAllowedPhi;
MinAllowedPhi -= 0.1 * Range;
MaxAllowedPhi += 0.1 * Range;
// timestep for pseudo-timestepping
double dt = 0.5 * this.GridDat.Cells.h_min[jCell] / (((double)(this.LevelSetBasis.Degree)).Pow2());
DGField[] PlotFields = new DGField[] { Phi, gradPhi[0], gradPhi[1], __DiffusionCoeff, __AcceptedMask };
//Tecplot.Tecplot.PlotFields(Params, "itt_0", "EllipicReinit", 0, 3);
double[] PrevVal = new double[N];
double[] NextVal = new double[N];
Phi.Coordinates.GetRow(jCell, PrevVal);
// pseudo-timestepping
//if(jCell == 80)
// Tecplot.Tecplot.PlotFields(PlotFields, "itt_0", "EllipicReinit", 0, 3);
//Console.Write(" Local solve cell " + jCell + " ... ");
bool converged = false;
double DiffusionCoeff = 0;
int IterGrowCount = 0; // number of iterations in which the residual grew
double LastResi = double.NaN;
for (int iIter = 0; iIter < 1000; iIter++)
{
//Console.Write(" Local solve iteration " + iIter + " ... ");
PerformRKstep(dt, jCell, AcceptedMask, Phi, gradPhi, evo);
__DiffusionCoeff.SetMeanValue(jCell, DiffusionCoeff);
if (jCell == 80)
{
DiffusionCoeff = 0.1;
}
if (DiffusionCoeff > 0)
{
//Console.WriteLine(" Diffusion on.");
double[] _DiffRhs = new double[this.LevelSetMapping.LocalLength];
dop.ComputeMatrixEx(this.LevelSetMapping, new DGField[] { Phi, gradPhi[0], gradPhi[1] }, this.LevelSetMapping,
default(MsrMatrix), _DiffRhs, OnlyAffine: true,
edgeQuadScheme: (new EdgeQuadratureScheme(domain: jCellGrid.AllEdgesMask)),
volQuadScheme: (new CellQuadratureScheme(domain: CellMask.GetEmptyMask(this.GridDat))));
// extract matrix for 'jCell'
for (int n = 0; n < N; n++)
{
DiffRhs[n] = _DiffRhs[i0L + n];
}
PerformArtificialDiffusion(dt * DiffusionCoeff, jCell, Phi, DiffMtx, DiffRhs);
}
Phi.Coordinates.GetRow(jCell, NextVal);
double resi = Math.Sqrt(GenericBlas.L2DistPow2(NextVal, PrevVal) / GenericBlas.L2NormPow2(PrevVal));
double[] A = NextVal;
NextVal = PrevVal;
PrevVal = A;
if (iIter > 0 && resi > LastResi)
{
IterGrowCount++;
}
else
{
IterGrowCount = 0;
}
LastResi = resi;
if (resi < 1.0e-10)
{
converged = true;
break;
}
double maxPhi, minPhi;
Phi.GetExtremalValuesInCell(out minPhi, out maxPhi, jCell);
bool MinAlarm = minPhi < MinAllowedPhi;
bool Maxalarm = maxPhi > MaxAllowedPhi;
bool GrowAlarm = IterGrowCount > 4;
bool IterAlarm = iIter >= 50;
if (MinAlarm || Maxalarm || GrowAlarm)
{
// Diffusion coefficient should be increased
if (DiffusionCoeff == 0)
{
DiffusionCoeff = 1.0e-2;
}
else
{
if (DiffusionCoeff < 1.0e3)
{
DiffusionCoeff *= 2;
}
}
//Console.WriteLine(" increasing Diffusion: {0}, Alarms : {1}{2}{3}{4}", DiffusionCoeff, MinAlarm ? 1 : 0, Maxalarm ? 1 : 0, GrowAlarm ? 1 : 0, IterAlarm ? 1 : 0);
}
//if(jCell == 80 && iIter < 100)
// Tecplot.Tecplot.PlotFields(PlotFields, "itt_" + (iIter + 1), "EllipicReinit", iIter + 1, 3);
}
return(converged);
}
/// <summary>
/// creates the spatial operator that consists only of component <paramref name="c"/>
/// </summary>
public static XSpatialOperatorMk2 XOperator(this IEquationComponent c, int DegreeOfNonlinearity = 1)
{
return(XOperator(c, QuadOrderFunc.NonLinear(DegreeOfNonlinearity)));
}
/// <summary>
/// creates the spatial operator that consists only of component <paramref name="c"/>
/// </summary>
public static XSpatialOperatorMk2 XOperator(this IEquationComponent c, IEnumerable <string> species, int DegreeOfNonlinearity = 1)
{
return(XOperator(c, species, QuadOrderFunc.NonLinear(DegreeOfNonlinearity)));
}
/// <summary>
/// Declaration of the spatial operator
/// </summary>
protected override SpatialOperator GetOperatorInstance(int D)
{
// instantiate boundary condition mapping
// ======================================
boundaryCondMap = new IncompressibleBoundaryCondMap(this.GridData, this.Control.BoundaryValues, PhysicsMode.Incompressible);
// instantiate operator
// ====================
string[] CodName = (new[] { "ResidualMomentumX", "ResidualMomentumY", "ResidualMomentumZ" }).GetSubVector(0, D).Cat("ResidualConti");
var op = new SpatialOperator(
__DomainVar: VariableNames.VelocityVector(D).Cat(VariableNames.Pressure),
__ParameterVar: VariableNames.GravityVector(D),
__CoDomainVar: CodName,
QuadOrderFunc: QuadOrderFunc.NonLinear(2));
op.LinearizationHint = LinearizationHint.GetJacobiOperator;
// Temporal Operator
// =================
var TempOp = new ConstantTemporalOperator(op, 0.0); // init with entire diagonal set to 0.0
op.TemporalOperator = TempOp;
for (int d = 0; d < D; d++)
{
TempOp.SetDiagonal(CodName[d], Control.Density); // set momentum equation entries to density
}
// Pressure Reference
// ==================
// if there is no Dirichlet boundary condition,
// the mean value of the pressure is free:
op.FreeMeanValue[VariableNames.Pressure] = !boundaryCondMap.DirichletPressureBoundary;
// Momentum Equation
// =================
// convective part:
{
for (int d = 0; d < D; d++)
{
var comps = op.EquationComponents[CodName[d]];
var ConvBulk = new LocalLaxFriedrichsConvection(D, boundaryCondMap, d, Control.Density);
comps.Add(ConvBulk); // bulk component
}
}
// pressure part:
{
for (int d = 0; d < D; d++)
{
var comps = op.EquationComponents[CodName[d]];
var pres = new PressureGradientLin_d(d, boundaryCondMap);
comps.Add(pres); // bulk component
}
}
// viscous part:
{
for (int d = 0; d < D; d++)
{
var comps = op.EquationComponents[CodName[d]];
double penalty_bulk = this.Control.PenaltySafety;
var Visc = new swipViscosity_Term1(penalty_bulk, d, D, boundaryCondMap,
ViscosityOption.ConstantViscosity,
constantViscosityValue: Control.Viscosity);
comps.Add(Visc); // bulk component GradUTerm
}
}
// Continuity equation
// ===================
{
for (int d = 0; d < D; d++)
{
var src = new Divergence_DerivativeSource(d, D);
var flx = new Divergence_DerivativeSource_Flux(d, boundaryCondMap);
op.EquationComponents[CodName[D]].Add(src);
op.EquationComponents[CodName[D]].Add(flx);
}
//IBM_Op.EquationComponents["div"].Add(new PressureStabilization(1, 1.0 / this.Control.PhysicalParameters.mu_A));
}
// Gravity parameter
// =================
op.ParameterFactories.Add(delegate(IReadOnlyDictionary <string, DGField> DomainVarFields) {
return(D.ForLoop(d => (VariableNames.Gravity_d(d), this.Gravity[d] as DGField)));
});
// commit & return
// ===============
op.Commit();
return(op);
}