protected override void CreateFields()
{
levelSet = testCase.GetLevelSet((BoSSS.Foundation.Grid.Classic.GridData)GridData);
levelSetTracker = new LevelSetTracker((BoSSS.Foundation.Grid.Classic.GridData)GridData,
XQuadFactoryHelper.MomentFittingVariants.Classic, // should have no effect, this app creates its own quad-rules independent of the tracker
1, new string[] { "A", "B" }, levelSet);
XDGField = new XDGField(
new XDGBasis(levelSetTracker, testCase.IntegrandDegree), "XDGField");
SinglePhaseField = new SinglePhaseField(
new Basis(GridData, testCase.IntegrandDegree), "SinglePhaseField");
if (levelSet is LevelSet)
{
m_IOFields.Add((LevelSet)levelSet);
}
else
{
LevelSet projectedLevelSet = new LevelSet(new Basis(GridData, 4), "projectedAnalyticLevelSet");
projectedLevelSet.ProjectField(testCase.GetLevelSet((BoSSS.Foundation.Grid.Classic.GridData)GridData).Evaluate);
m_IOFields.Add(projectedLevelSet);
}
m_IOFields.Add(XDGField);
m_IOFields.Add(SinglePhaseField);
}
/// <summary>
/// Sets level-set and solution at time (<paramref name="time"/> + <paramref name="dt"/>).
/// </summary>
double DelUpdateLevelset(DGField[] CurrentState, double time, double dt, double UnderRelax, bool _incremental)
{
// new time
double t = time + dt;
// project new level-set
double s = 1.0;
LevSet.ProjectField((x, y) => - (x - s * t).Pow2() - y.Pow2() + (2.4).Pow2());
LsTrk.UpdateTracker(incremental: _incremental);
// exact solution for new timestep
uEx.GetSpeciesShadowField("A").ProjectField((x, y) => x + alpha_A * t);
uEx.GetSpeciesShadowField("B").ProjectField((x, y) => x + alpha_B * t);
u.Clear();
u.Acc(1.0, uEx);
// markieren, wo ueberhaupt A und B sind
Amarker.Clear();
Bmarker.Clear();
Amarker.AccConstant(+1.0, LsTrk.Regions.GetSpeciesSubGrid("A").VolumeMask);
Bmarker.AccConstant(1.0, LsTrk.Regions.GetSpeciesSubGrid("B").VolumeMask);
// MPI rank
MPICellRank.Clear();
MPICellRank.AccConstant(base.MPIRank);
// return level-set residual
return(0.0);
}
/// <summary>
/// Sets level-set and solution at time (<paramref name="time"/> + <paramref name="dt"/>).
/// </summary>
double DelUpdateLevelset(DGField[] CurrentState, double time, double dt, double UnderRelax, bool _incremental)
{
// new time
double t = time + dt;
// project new level-set
double s = 1.0;
LevSet.ProjectField((x, y) => - (x - s * t).Pow2() - y.Pow2() + (2.4).Pow2());
LsTrk.UpdateTracker(incremental: _incremental);
LsTrk.PushStacks();
// exact solution for new timestep
uXEx.GetSpeciesShadowField("A").ProjectField((x, y) => x + alpha_A * t);
uXEx.GetSpeciesShadowField("B").ProjectField((x, y) => x + alpha_B * t);
// uX.Clear();
//uX.Acc(1.0, uXEx);
// single-phase-properties
u.Clear();
u.ProjectField(NonVectorizedScalarFunction.Vectorize(uEx, t));
Grad_u.Clear();
Grad_u.Gradient(1.0, u);
MagGrad_u.Clear();
MagGrad_u.ProjectFunction(1.0,
(double[] X, double[] U, int jCell) => Math.Sqrt(U[0].Pow2() + U[1].Pow2()),
new Foundation.Quadrature.CellQuadratureScheme(),
Grad_u.ToArray());
// return level-set residual
return(0.0);
}
/// <summary>
/// Sets level-set and solution at time (<paramref name="time"/> + <paramref name="dt"/>).
/// </summary>
double DelUpdateLevelset(DGField[] CurrentState, double time, double dt, double UnderRelax, bool _incremental)
{
// new time
double t = time + dt;
// project new level-set
LevSet.ProjectField(this.Control.LevelSet.Vectorize(t));
LsTrk.UpdateTracker(incremental: _incremental);
// exact solution for new timestep
uEx.GetSpeciesShadowField("A").ProjectField(NonVectorizedScalarFunction.Vectorize(this.Control.uEx_A, t));
uEx.GetSpeciesShadowField("B").ProjectField(NonVectorizedScalarFunction.Vectorize(this.Control.uEx_B, t));
u.Clear();
u.Acc(1.0, uEx);
// markieren, wo ueberhaupt A und B sind
Amarker.Clear();
Bmarker.Clear();
Amarker.AccConstant(+1.0, LsTrk._Regions.GetSpeciesSubGrid("A").VolumeMask);
Bmarker.AccConstant(1.0, LsTrk._Regions.GetSpeciesSubGrid("B").VolumeMask);
// MPI rank
MPICellRank.Clear();
MPICellRank.AccConstant(base.MPIRank);
// return level-set residual
return(0.0);
}
//internal double THRESHOLD = 0;
void LsUpdate(double t)
{
double offset = t;
Phi.ProjectField((x, y) => - (x - offset).Pow2() - y.Pow2() + (0.707).Pow2());
LsTrk.UpdateTracker(t);
}
/// <summary>
/// Projects the initial level set after calling
/// <see cref="CNSFieldSet.ProjectInitialValues"/>
/// </summary>
/// <param name="speciesMap"></param>
/// <param name="initialValues"></param>
public override void ProjectInitialValues(ISpeciesMap speciesMap, IDictionary <string, Func <double[], double> > initialValues)
{
LevelSet.ProjectField(NonVectorizedScalarFunction.Vectorize(
X => config.LevelSetFunction(X, 0.0)));
speciesMap.As <ImmersedSpeciesMap>().Tracker.UpdateTracker(0.0);
base.ProjectInitialValues(speciesMap, initialValues);
}
void LsUpdate(double t)
{
double offset = t;
Phi.ProjectField((x, y) => - (x - offset).Pow2() - y.Pow2() + (2.4).Pow2());
//Phi.ProjectField((x, y) => x);
//Console.WriteLine("more testcode");
LsTrk.UpdateTracker();
}
public override void UpdateLevelSet(ILevelSet levelSet)
{
LevelSet levelSetField = levelSet as LevelSet;
if (levelSetField == null)
{
throw new ArgumentException();
}
levelSetField.ProjectField(LevelSetInitialValue);
}
void LsUpdate(double t)
{
double offset = t;
Console.WriteLine("LSUpdate t = " + t);
Phi0.ProjectField((x, y) => - (x - offset).Pow2() - y.Pow2() + (0.85).Pow2());
Phi1.ProjectField((x, y) => - (x - offset).Pow2() - y.Pow2() + (2.4).Pow2());
LsTrk.UpdateTracker();
if (LsTrk.Regions.GetSpeciesSubGrid("X").GlobalNoOfCells > 0)
{
throw new ApplicationException("there should be no X-species");
}
}
public override void UpdateLevelSet(ILevelSet levelSet)
{
//AnalyticStarLevelSet analyticLevelSet = levelSet as AnalyticStarLevelSet;
//if (analyticLevelSet == null) {
// throw new Exception();
//}
//analyticLevelSet.SetParameters(CurrentShift.OffsetX, CurrentShift.OffsetY);
LevelSet levelSetField = levelSet as LevelSet;
if (levelSetField == null)
{
throw new Exception();
}
levelSetField.ProjectField(LevelSetInitialValue);
}
public override void UpdateLevelSet(ILevelSet levelSet)
{
//AnalyticSphereLevelSet analyticLevelSet = levelSet as AnalyticSphereLevelSet;
//if (analyticLevelSet == null) {
// throw new Exception();
//}
//analyticLevelSet.SetOffset(CurrentShift.OffsetX, CurrentShift.OffsetY, CurrentShift.OffsetZ);
LevelSet field = levelSet as LevelSet;
if (field == null)
{
throw new Exception();
}
field.ProjectField(LevelSetInitialValue);
}
protected void MoveLevelSetTo(double time)
{
LevelSet levelSet = speciesMap.Tracker.LevelSets[0].As <LevelSet>();
levelSet.Clear();
levelSet.ProjectField(X => speciesMap.Control.LevelSetFunction(X, time));
speciesMap.Tracker.UpdateTracker();
cutCells = speciesMap.Tracker.Regions.GetCutCellMask();
cutAndTargetCells = cutCells.Union(speciesMap.Agglomerator.AggInfo.TargetCells);
// EVIL HACK SINCE UPDATE OF GRADIENT ONLY HAPPENS AFTER TIME-STEP SO FAR
foreach (var gradientField in boundaryParameterMap.Fields)
{
int d = int.Parse(gradientField.Identification.Last().ToString());
gradientField.Clear();
gradientField.Derivative(
-1.0,
levelSet,
d,
cutCells);
}
}
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
}
}
});
}
protected override void SetInitial()
{
Phi.ProjectField(test.GetLevelSet);
this.LsTrk.UpdateTracker(0.0);
}
