protected override void CreateFields()
{
var Basis = new Basis(base.GridData, DEGREE);
u = new SinglePhaseField(Basis, "u");
Grad_u = new VectorField <SinglePhaseField>(base.GridData.SpatialDimension, Basis, "Grad_u", (bs, nmn) => new SinglePhaseField(bs, nmn));
MagGrad_u = new SinglePhaseField(new Basis(base.GridData, 0), "Magnitude_Grad_u");
TestData = new SinglePhaseField(Basis, "TestData");
base.m_RegisteredFields.Add(u);
base.m_RegisteredFields.AddRange(Grad_u);
base.m_RegisteredFields.Add(MagGrad_u);
base.m_RegisteredFields.Add(TestData);
LevSet = new LevelSet(new Basis(this.GridData, 2), "LevelSet");
base.LsTrk = new LevelSetTracker((BoSSS.Foundation.Grid.Classic.GridData) this.GridData, XQuadFactoryHelper.MomentFittingVariants.OneStepGaussAndStokes, 1, new string[] { "A", "B" }, LevSet);
base.m_RegisteredFields.Add(LevSet);
var xBasis = new XDGBasis(base.LsTrk, DEGREE);
uX = new XDGField(xBasis, "uX");
uXResidual = new XDGField(xBasis, "ResX");
uXEx = new XDGField(xBasis, "uXEx");
uX.UpdateBehaviour = BehaveUnder_LevSetMoovement.JustReallocate;
uXResidual.UpdateBehaviour = BehaveUnder_LevSetMoovement.JustReallocate;
uXEx.UpdateBehaviour = BehaveUnder_LevSetMoovement.JustReallocate;
base.m_RegisteredFields.Add(uX);
base.m_RegisteredFields.Add(uXResidual);
base.m_RegisteredFields.Add(uXEx);
}
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);
}
public static void ProjectKineticDissipation(this XDGField proj, LevelSetTracker LsTrk, DGField[] Velocity, double[] mu, int momentFittingOrder, int HistInd = 1)
{
using (new FuncTrace()) {
int D = LsTrk.GridDat.SpatialDimension;
if (Velocity.Count() != D)
{
throw new ArgumentException();
}
if (LsTrk.SpeciesIdS.Count != mu.Length)
{
throw new ArgumentException();
}
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(LsTrk.SpeciesIdS.ToArray(), momentFittingOrder, HistInd).XQuadSchemeHelper;
for (int iSpc = 0; iSpc < LsTrk.SpeciesIdS.Count; iSpc++)
{
SpeciesId spcId = LsTrk.SpeciesIdS[iSpc];
double _mu = mu[iSpc];
var Uspc = Velocity.Select(u => (u as XDGField).GetSpeciesShadowField(spcId)).ToArray();
ScalarFunctionEx spcKinDissip = GetSpeciesKineticDissipationFunc(Uspc, _mu);
proj.GetSpeciesShadowField(spcId).ProjectField(spcKinDissip);
}
}
}
public DGField[] ProlongateToDg(double[] V, string name)
{
double[] Curr = ProlongateToTop(V);
var gdat = m_op.BaseGridProblemMapping.GridDat;
var basisS = m_op.BaseGridProblemMapping.BasisS;
DGField[] dgCurrentSol = new DGField[basisS.Count];
for (int i = 0; i < basisS.Count; i++)
{
var basis = basisS[i];
if (basis is XDGBasis)
{
dgCurrentSol[i] = new XDGField((XDGBasis)basis, name + i);
}
else
{
dgCurrentSol[i] = new SinglePhaseField(basis, name + i);
}
}
CoordinateVector cv = new CoordinateVector(dgCurrentSol);
m_op.FinestLevel.TransformSolFrom(cv, Curr);
return(dgCurrentSol);
}
public static double EnergyBalanceNormAtInterface(XDGField P, VectorField <XDGField> U, ConventionalDGField[] Umean, SinglePhaseField C, double muA, double muB, double sigma, int momentFittingOrder)
{
LevelSetTracker LsTrk = P.Basis.Tracker;
double energyBal_Norm = 0.0;
ScalarFunctionEx energyBalFunc = GetEnergyBalanceFunc(P, U, Umean, C, muA, muB, sigma, true);
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingOrder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
energyBalFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
energyBal_Norm += ResultsOfIntegration[i, 0];
}
}
).Execute();
return(energyBal_Norm.Sqrt());
}
protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt)
{
dt = 1.0;
base.NoOfTimesteps = 1;
Console.WriteLine("Timestep #{0}, dt = {1} ...", TimestepNo, dt);
// test the auto-extrapolation
// ---------------------------
double x0 = 0.17 * (phystime + dt);
this.Pressure.UpdateBehaviour = BehaveUnder_LevSetMoovement.AutoExtrapolate;
this.LevSet.ProjectField((_2D)((x, y) => ((x - 0.83 - x0) / 0.8).Pow2() + (y / 0.8).Pow2() - 1.0));
this.LsTrk.UpdateTracker();
var RefPressure = new XDGField(this.Pressure.Basis);
RefPressure.ProjectField((_2D)((x, y) => 1 - y * y));
RefPressure.Acc(-1.0, Pressure);
AutoExtrapolationErr = RefPressure.L2Norm();
Console.WriteLine("Error of extrapolation: " + AutoExtrapolationErr);
// PlotCurrentState(phystime + dt, TimestepNo);
Console.WriteLine("done.");
return(dt);
}
void TestAgglomeration_Extraploation(MultiphaseCellAgglomerator Agg)
{
_2D SomePolynomial;
if (this.u.Basis.Degree == 0)
{
SomePolynomial = (x, y) => 3.2;
}
else if (this.u.Basis.Degree == 1)
{
SomePolynomial = (x, y) => 3.2 + x - 2.4 * y;
}
else
{
SomePolynomial = (x, y) => x * x + y * y;
}
// ========================================================
// extrapolate polynomial function for species B of a XDG-field
// ========================================================
var Bmask = LsTrk.Regions.GetSpeciesMask("B");
XDGField xt = new XDGField(new XDGBasis(this.LsTrk, this.u.Basis.Degree), "XDG-test");
xt.GetSpeciesShadowField("B").ProjectField(1.0,
SomePolynomial.Vectorize(),
new CellQuadratureScheme(true, Bmask));
double[] bkupVec = xt.CoordinateVector.ToArray();
Agg.ClearAgglomerated(xt.Mapping);
Agg.Extrapolate(xt.Mapping);
double Err = GenericBlas.L2DistPow2(bkupVec, xt.CoordinateVector).MPISum().Sqrt();
Console.WriteLine("Agglom: extrapolation error: " + Err);
Assert.LessOrEqual(Err, 1.0e-10);
// ========================================================
// extrapolate polynomial function for a single-phase-field
// ========================================================
SinglePhaseField xt2 = new SinglePhaseField(this.u.Basis, "DG-test");
xt2.ProjectField(SomePolynomial);
double[] bkupVec2 = xt2.CoordinateVector.ToArray();
Agg.ClearAgglomerated(xt2.Mapping);
Agg.Extrapolate(xt2.Mapping);
double Err2 = GenericBlas.L2DistPow2(bkupVec, xt.CoordinateVector).MPISum().Sqrt();
Console.WriteLine("Agglom: extrapolation error: " + Err2);
Assert.LessOrEqual(Err2, 1.0e-10);
}
protected override void CreateFields()
{
Phi0 = new LevelSet(new Basis(this.GridData, 2), "Phi_0");
Phi1 = new LevelSet(new Basis(this.GridData, 2), "Phi_1");
if (usePhi0 && usePhi1)
{
string[,] speciesTable = new string[2, 2];
speciesTable[0, 0] = "A"; // rechter Rand von A
speciesTable[0, 1] = "B"; // Species zwischen den LevelSets
speciesTable[1, 0] = "X"; // 'verbotene' Species: sollte in der geg. LevelSet-Konstellation nicht vorkommen!
speciesTable[1, 1] = "A"; // linker Rand von A
base.LsTrk = new LevelSetTracker((BoSSS.Foundation.Grid.Classic.GridData)(this.GridData), MomentFittingVariant, 1, speciesTable, Phi0, Phi1);
}
else if (!usePhi0 && usePhi1)
{
string[] speciesTable = new string[2];
speciesTable[0] = "A";
speciesTable[1] = "B";
base.LsTrk = new LevelSetTracker((BoSSS.Foundation.Grid.Classic.GridData)(this.GridData), MomentFittingVariant, 1, speciesTable, Phi1);
}
else if (usePhi0 && !usePhi1)
{
string[] speciesTable = new string[2];
speciesTable[0] = "B";
speciesTable[1] = "A";
base.LsTrk = new LevelSetTracker((BoSSS.Foundation.Grid.Classic.GridData)(this.GridData), MomentFittingVariant, 1, speciesTable, Phi0);
}
else
{
throw new NotImplementedException();
}
u = new SinglePhaseField(new Basis(this.GridData, DEGREE), "U");
du_dx = new SinglePhaseField(new Basis(this.GridData, DEGREE), "du_dx");
du_dx_Exact = new SinglePhaseField(new Basis(this.GridData, DEGREE), "du_dx_exact");
ERR = new SinglePhaseField(new Basis(this.GridData, DEGREE), "ERROR");
XERR = new XDGField(new XDGBasis(LsTrk, DEGREE), "ERROR_xdg");
Amarker = new SinglePhaseField(new Basis(this.GridData, 0), "Amarker");
Bmarker = new SinglePhaseField(new Basis(this.GridData, 0), "Bmarker");
Xmarker = new SinglePhaseField(new Basis(this.GridData, 0), "Xmarker");
base.m_RegisteredFields.Add(Phi0);
base.m_RegisteredFields.Add(Phi1);
base.m_RegisteredFields.Add(u);
base.m_RegisteredFields.Add(du_dx);
base.m_RegisteredFields.Add(du_dx_Exact);
base.m_RegisteredFields.Add(ERR);
base.m_RegisteredFields.Add(XERR);
base.m_RegisteredFields.Add(Amarker);
base.m_RegisteredFields.Add(Bmarker);
base.m_RegisteredFields.Add(Xmarker);
}
protected override void CreateFields()
{
this.LevSet = new LevelSet(new Basis(this.GridData, Control.FieldOptions["Phi"].Degree), "Phi");
this.LsTrk = new LevelSetTracker((GridData)this.GridData, XQuadFactoryHelper.MomentFittingVariants.Classic, 1, new string[] { "A", "B" }, LevSet);
Pressure = new XDGField(new XDGBasis(this.LsTrk, Control.FieldOptions["Pressure"].Degree), "Pressure");
IOFields.Add(this.LevSet);
IOFields.Add(this.Pressure);
Amarker = new SinglePhaseField(new Basis(this.GridData, 0), "SpeciesA");
Bmarker = new SinglePhaseField(new Basis(this.GridData, 0), "SpeciesB");
}
public static void ProjectKineticEnergy(this XDGField proj, LevelSetTracker LsTrk, XDGField[] Velocity, double[] rho, int momentFittingOrder, int HistInd = 1)
{
using (new FuncTrace()) {
int D = LsTrk.GridDat.SpatialDimension;
if (Velocity.Count() != D)
{
throw new ArgumentException();
}
if (LsTrk.SpeciesIdS.Count != rho.Length)
{
throw new ArgumentException();
}
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(LsTrk.SpeciesIdS.ToArray(), momentFittingOrder, HistInd).XQuadSchemeHelper;
for (int iSpc = 0; iSpc < LsTrk.SpeciesIdS.Count; iSpc++)
{
SpeciesId spcId = LsTrk.SpeciesIdS[iSpc];
double _rho = rho[iSpc];
var Uspc = Velocity.Select(u => (u as XDGField).GetSpeciesShadowField(spcId)).ToArray();
//ScalarFunctionEx spcKinDissip = GetSpeciesKineticDissipationFunc(Uspc, _rho);
ScalarFunctionEx spcKinEnergy = delegate(int i0, int Len, NodeSet nds, MultidimensionalArray result) {
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray U_res = MultidimensionalArray.Create(Len, K, D);
for (int i = 0; i < D; i++)
{
Uspc[i].Evaluate(i0, Len, nds, U_res.ExtractSubArrayShallow(-1, -1, i));
}
double acc;
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
acc = 0.0;
for (int d = 0; d < D; d++)
{
acc += U_res[j, k, d] * U_res[j, k, d];
}
result[j, k] = _rho * acc / 2.0;
}
}
};
proj.GetSpeciesShadowField(spcId).ProjectField(spcKinEnergy);
}
}
}
static void SetTestValue(XDGField Xf, IDictionary <SpeciesId, double> mod)
{
var Tracker = Xf.Basis.Tracker;
foreach (var S in Tracker.SpeciesIdS)
{
var f = Xf.GetSpeciesShadowField(S);
SetTestValue(f);
f.Scale(mod[S]);
//f.AccConstant(accVal[S]);
}
}
#pragma warning restore 649
/// <summary>
/// creates energy related fields
/// </summary>
public void CreateEnergyFields()
{
int D = this.GridData.SpatialDimension;
IOListOption register = (this.Control.RegisterUtilitiesToIOFields) ? IOListOption.Always : IOListOption.ControlFileDetermined;
if (this.Control.solveKineticEnergyEquation)
{
this.KineticEnergy = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), VariableNames.KineticEnergy);
base.RegisterField(this.KineticEnergy);
this.ResidualKineticEnergy = new XDGField(this.KineticEnergy.Basis, "ResidualKineticEnergy");
base.RegisterField(this.ResidualKineticEnergy);
//this.prevKineticEnergy = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions["KineticEnergy"].Degree)));
this.GeneratedKineticEnergy = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "GeneratedKineticEnergy");
base.RegisterField(this.GeneratedKineticEnergy, register);
this.KineticEnergyChangerate = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "KineticEnergyChangerate");
base.RegisterField(this.KineticEnergyChangerate, register);
}
if (this.Control.ComputeEnergyProperties)
{
if (this.Control.TimesteppingMode == AppControl._TimesteppingMode.Transient)
{
prevVel = new XDGField[D];
for (int d = 0; d < D; d++)
{
prevVel[d] = new XDGField(this.XDGvelocity.Velocity[d].Basis);
}
}
this.prevKineticEnergy = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "previousKineticEnergy");
base.RegisterField(this.prevKineticEnergy);
this.DerivedKineticEnergy = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "DerivedKineticEnergy");
base.RegisterField(this.DerivedKineticEnergy, register);
this.DerivedKineticEnergyChangerate = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "DerivedKineticEnergyChangerate");
base.RegisterField(this.DerivedKineticEnergyChangerate, register);
this.KineticDissipation = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "KineticDissipation");
base.RegisterField(this.KineticDissipation, register);
this.PowerOfStresses = new XDGField(new XDGBasis(this.LsTrk, (this.Control.FieldOptions[VariableNames.KineticEnergy].Degree)), "PowerOfStresses");
base.RegisterField(this.PowerOfStresses, register);
}
}
/// <summary>
/// Injects an XDG field from a coarsr grid to a fine grid.
/// </summary>
public static XDGField InjectXDGField(int[] Fine2Coarse, XDGField injected, XDGField cors_field, CellMask subGrd = null)
{
var trk = injected.Basis.Tracker;
foreach (var spc in trk.SpeciesIdS)
{
var grd = trk.Regions.GetSpeciesMask(spc);
InjectDGField(Fine2Coarse,
injected.GetSpeciesShadowField(spc),
cors_field.GetSpeciesShadowField(spc),
subGrd == null ? grd : grd.Intersect(subGrd));
}
return(injected);
}
protected void SetHomotopyValue(double HomotopyValue)
{
if (HomotopyValue < 0)
{
throw new ArgumentOutOfRangeException();
}
if (HomotopyValue > 1)
{
throw new ArgumentOutOfRangeException();
}
if (AbstractOperator == null && HomotopyValue != 1)
{
// do one call just to attain the spatial operator;
// not very efficient, but ok for the moment
var dummyState = this.CurrentLin.BaseGridProblemMapping.BasisS.Select(delegate(Basis b) {
DGField r;
if (b is XDGBasis xb)
{
r = new XDGField(xb);
}
else
{
r = new SinglePhaseField(b);
}
return(r);
}).ToArray();
this.m_AssembleMatrix(out var OpMtxRaw, out _, out _, dummyState, false, out var _Dummy);
Debug.Assert(OpMtxRaw == null); // only evaluation ==> OpMatrix must be null
this.AbstractOperator = _Dummy;
}
if (AbstractOperator == null && HomotopyValue != 1.0)
{
throw new NotSupportedException("unable to attain operator for homotopy update");
}
if (AbstractOperator != null && HomotopyValue != AbstractOperator.CurrentHomotopyValue)
{
// set homotopy value
AbstractOperator.CurrentHomotopyValue = HomotopyValue;
}
}
protected override double RunSolverOneStep(int TimestepNo, double phystime, double dt)
{
dt = Control.dtFixed;
Console.WriteLine("Timestep #{0}, dt = {1} ...", TimestepNo, dt);
// advance level-set
// -----------------
double x0 = 0.17 * (phystime + dt);
this.Pressure.UpdateBehaviour = BehaveUnder_LevSetMoovement.AutoExtrapolate;
this.LevSet.ProjectField((_2D)((x, y) => Phi(new[] { x, y }, x0)));
this.LsTrk.PushStacks();
this.LsTrk.UpdateTracker(phystime + dt);
// update markers
// --------------
this.Amarker.Clear();
this.Bmarker.Clear();
this.Amarker.AccConstant(1.0, this.LsTrk.Regions.GetSpeciesMask("A"));
this.Bmarker.AccConstant(1.0, this.LsTrk.Regions.GetSpeciesMask("B"));
// test the auto-extrapolation
// ---------------------------
var RefPressure = new XDGField(this.Pressure.Basis);
RefPressure.GetSpeciesShadowField("A").ProjectField(PressureExactA);
RefPressure.GetSpeciesShadowField("B").ProjectField(PressureExactB);
RefPressure.Acc(-1.0, Pressure);
AutoExtrapolationErr = RefPressure.L2Norm();
Console.WriteLine("Error of extrapolation: " + AutoExtrapolationErr);
Assert.LessOrEqual(AutoExtrapolationErr, 1.0e-8, "Error after auto-extrapolation to high.");
Console.WriteLine("done.");
return(dt);
}
public DGField ProlongateToDg(double[] V, string name)
{
double[] Curr = ProlongateToTop(V);
var gdat = m_op.BaseGridProblemMapping.GridDat;
var basis = m_op.BaseGridProblemMapping.BasisS[0];
DGField dgCurrentSol;
if (basis is XDGBasis)
{
dgCurrentSol = new XDGField((XDGBasis)basis, name);
}
else
{
dgCurrentSol = new SinglePhaseField(basis, name);
}
m_op.FinestLevel.TransformSolFrom(dgCurrentSol.CoordinateVector, Curr);
return(dgCurrentSol);
}
protected override void CreateFields()
{
LevSet = new LevelSet(new Basis(this.GridData, 2), "LevelSet");
base.LsTrk = new LevelSetTracker(this.GridData, 1, new string[] { "A", "B" }, LevSet);
var xBasis = new XDGBasis(base.LsTrk, DEGREE);
u = new XDGField(xBasis, "u");
uResidual = new XDGField(xBasis, "Res");
uEx = new XDGField(xBasis, "uEx");
Amarker = new SinglePhaseField(new Basis(this.GridData, 0), "Amarker");
Bmarker = new SinglePhaseField(new Basis(this.GridData, 0), "Bmarker");
MPICellRank = new SinglePhaseField(new Basis(this.GridData, 0), "MPIRank");
base.m_RegisteredFields.Add(LevSet);
base.m_RegisteredFields.Add(u);
base.m_RegisteredFields.Add(uEx);
base.m_RegisteredFields.Add(uResidual);
base.m_RegisteredFields.Add(Amarker);
base.m_RegisteredFields.Add(Bmarker);
base.m_RegisteredFields.Add(MPICellRank);
}
protected override void CreateFields()
{
LevSet = new LevelSet(new Basis(this.GridData, 2), "LevelSet");
base.LsTrk = new LevelSetTracker((GridData)this.GridData, XQuadFactoryHelper.MomentFittingVariants.OneStepGaussAndStokes, 1, new string[] { "A", "B" }, LevSet);
var xBasis = new XDGBasis(base.LsTrk, DEGREE);
u = new XDGField(xBasis, "u");
uResidual = new XDGField(xBasis, "Res");
uEx = new XDGField(xBasis, "uEx");
Amarker = new SinglePhaseField(new Basis(this.GridData, 0), "Amarker");
Bmarker = new SinglePhaseField(new Basis(this.GridData, 0), "Bmarker");
MPICellRank = new SinglePhaseField(new Basis(this.GridData, 0), "MPIRank");
base.m_RegisteredFields.Add(LevSet);
base.m_RegisteredFields.Add(u);
base.m_RegisteredFields.Add(uEx);
base.m_RegisteredFields.Add(uResidual);
base.m_RegisteredFields.Add(Amarker);
base.m_RegisteredFields.Add(Bmarker);
base.m_RegisteredFields.Add(MPICellRank);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sessionPath">Path where everything is stored</param>
/// <param name="session">The session from the database</param>
/// <param name="input">
/// Lenghts --> [0]: numOfPoints, [1]: maxIterations + 1, [2]: 5
/// [2]: x | y | function values | second derivatives | step sizes
/// </param>
/// <param name="inputExtended">
/// Lenghts --> [0]: numOfPoints, [1]: 3
/// [1]: IterationsNeeded | Converged | jCell
/// </param>
public LevelSetReconstruction(string sessionPath, ISessionInfo session, MultidimensionalArray input, MultidimensionalArray inputExtended)
{
this.SessionPath = sessionPath;
this.Session = session;
this.input = input;
this.inputExtended = inputExtended;
ITimestepInfo myTimestep = session.Timesteps.Last();
this.gridData = (GridData)myTimestep.Fields.First().GridDat;
if (myTimestep.Fields.Where(f => f.Identification == "rho").SingleOrDefault() is XDGField)
{
XDGField densityField = (XDGField)myTimestep.Fields.Where(f => f.Identification == "rho").SingleOrDefault();
this.densityField = new SinglePhaseField(new Basis(gridData, densityField.Basis.Degree), "rho");
this.densityField.Acc(1.0, densityField.GetSpeciesShadowField("B"));
}
else
{
this.densityField = (SinglePhaseField)myTimestep.Fields.Where(f => f.Identification == "rho").SingleOrDefault();
}
this.geometryLevelSetField = (SinglePhaseField)myTimestep.Fields.Where(f => f.Identification == "levelSet").SingleOrDefault();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sessionPath">Path where everything is stored</param>
/// <param name="tsi">A time step from the database</param>
public InflectionPointFinder(string sessionPath, ITimestepInfo tsi)
{
this.SessionPath = sessionPath;
this.tsi = tsi;
this.gridData = (GridData)tsi.Fields.First().GridDat;
if (tsi.Fields.Where(f => f.Identification == "rho").SingleOrDefault() is XDGField)
{
XDGField densityField = (XDGField)tsi.Fields.Where(f => f.Identification == "rho").SingleOrDefault();
XDGField avField = (XDGField)tsi.Fields.Where(f => f.Identification == "artificialViscosity").SingleOrDefault();
this.densityField = new SinglePhaseField(new Basis(gridData, densityField.Basis.Degree), "rho");
this.densityField.Acc(1.0, densityField.GetSpeciesShadowField("B"));
this.levelSetField = (SinglePhaseField)tsi.Fields.Where(f => f.Identification == "levelSet").SingleOrDefault();
}
else
{
this.densityField = (SinglePhaseField)tsi.Fields.Where(f => f.Identification == "rho").SingleOrDefault();
this.avField = (SinglePhaseField)tsi.Fields.Where(f => f.Identification == "artificialViscosity").SingleOrDefault();
this.levelSetField = (SinglePhaseField)tsi.Fields.Where(f => f.Identification == "levelSet").SingleOrDefault();
}
}
#pragma warning restore 649
/// <summary>
/// creates heat equation related fields
/// </summary>
public void CreateHeatFields()
{
int D = this.GridData.SpatialDimension;
this.Temperature = new XDGField(new XDGBasis(this.LsTrk, this.Control.FieldOptions[VariableNames.Temperature].Degree), VariableNames.Temperature);
base.RegisterField(this.Temperature);
this.ResidualHeat = new XDGField(this.Temperature.Basis, "ResidualHeat");
base.RegisterField(this.ResidualHeat);
this.HeatFlux = new VectorField <XDGField>(D.ForLoop(d => new XDGField(new XDGBasis(this.LsTrk, this.Control.FieldOptions[VariableNames.HeatFluxVectorComponent(d)].Degree), VariableNames.HeatFluxVectorComponent(d))));
base.RegisterField(this.HeatFlux);
if (this.Control.conductMode != ConductivityInSpeciesBulk.ConductivityMode.SIP)
{
this.ResidualAuxHeatFlux = new VectorField <XDGField>(D.ForLoop(d => new XDGField(new XDGBasis(this.LsTrk, this.Control.FieldOptions[VariableNames.HeatFluxVectorComponent(d)].Degree), VariableNames.ResidualAuxHeatFluxVectorComponent(d))));
base.RegisterField(this.ResidualAuxHeatFlux);
}
this.DisjoiningPressure = new SinglePhaseField(new Basis(this.GridData, this.Control.FieldOptions[VariableNames.Pressure].Degree), "DisjoiningPressure");
if (this.Control.DisjoiningPressureFunc != null)
{
DisjoiningPressure.ProjectField(this.Control.DisjoiningPressureFunc);
}
base.RegisterField(this.DisjoiningPressure);
}
public static void XDG_ProlongationTest(
[Values(0, 1, 2, 3)] int p,
[Values(0.0, 0.3)] double AggregationThreshold,
[Values(0, 1)] int TrackerWidth,
[Values(MultigridOperator.Mode.Eye, MultigridOperator.Mode.IdMass)] MultigridOperator.Mode mode)
{
XQuadFactoryHelper.MomentFittingVariants variant = XQuadFactoryHelper.MomentFittingVariants.OneStepGaussAndStokes;
var xt = new XDGTestSetup(p, AggregationThreshold, TrackerWidth, MultigridOperator.Mode.Eye, variant
//, ((Func<double[], double>)(X => X[0] + 0.75)).Vectorize()
);
int Jup = grid.Cells.NoOfLocalUpdatedCells;
Random rnd = new Random();
int Ltop = xt.XdgMultigridOp.Mapping.LocalLength; // Number of DOF's on top multigrid level.
double[] RndVec = Ltop.ForLoop(i => rnd.NextDouble());
double[] NoJmpVec = new double[Ltop];
for (int iLevel = 0; iLevel < MgSeq.Length - 1; iLevel++)
{
XDG_Recursive(0, iLevel, xt.XdgMultigridOp, RndVec, NoJmpVec); // restrict RndVec downt to level 'iLevel', and back up
// right now, the XDG field defined by 'NoJmpVec' should be a member
// of the aggregated XDG space on level 'iLevel';
// so, there should be no inter-element jumps on the fine level, for each aggregated cell.
// Let's test that!
XDGField Test = new XDGField(xt.XB, "Test");
xt.XdgMultigridOp.TransformSolFrom(Test.CoordinateVector, NoJmpVec);
//xt.agg.Extrapolate(Test.Mapping);
var aggGrd = MgSeq[iLevel];
foreach (var spc in xt.LsTrk.SpeciesIdS)
{
var Test_spc = Test.GetSpeciesShadowField(spc);
var SpcMask = xt.LsTrk.Regions.GetSpeciesMask(spc);
BitArray AggSourceBitmask = xt.agg.GetAgglomerator(spc).AggInfo.SourceCells.GetBitMask();
double Err = 0;
for (int jagg = 0; jagg < aggGrd.iLogicalCells.NoOfLocalUpdatedCells; jagg++)
{
BitArray CompCellMask = new BitArray(Jup);
foreach (int jCell in aggGrd.iLogicalCells.AggregateCellToParts[jagg])
{
if (!AggSourceBitmask[jCell])
{
CompCellMask[jCell] = true;
}
}
SubGrid CompCellSubGrid = new SubGrid((new CellMask(grid, CompCellMask)).Intersect(SpcMask));
Err += JumpNorm(Test_spc, CompCellSubGrid.InnerEdgesMask).Pow2();
}
Console.WriteLine("prolongation jump test (level {0}, species {2}): {1}", iLevel, Err, xt.LsTrk.GetSpeciesName(spc));
Assert.LessOrEqual(Err, 1.0e-8);
}
}
}
public static void XDG_MatrixPolynomialRestAndPrlgTest(
[Values(0, 1, 2, 3)] int p,
[Values(0.0, 0.3)] double AggregationThreshold,
[Values(0, 1)] int TrackerWidth)
{
XQuadFactoryHelper.MomentFittingVariants variant = XQuadFactoryHelper.MomentFittingVariants.OneStepGaussAndStokes;
var xt = new XDGTestSetup(p, AggregationThreshold, TrackerWidth, MultigridOperator.Mode.Eye, variant);
// test matrix version of the restriction operator
// -----------------------------------------------
List <MultigridMapping> MultigridMaps = new List <MultigridMapping>();
for (var mgop = xt.XdgMultigridOp; mgop != null; mgop = mgop.CoarserLevel)
{
MultigridMaps.Add(mgop.Mapping);
}
for (int iLevel = 0; iLevel < MgSeq.Length; iLevel++)
{
MultigridMapping mgMap = MultigridMaps[iLevel];
var XAggBasis = mgMap.AggBasis[0];
// set the test field:
XDGField Test = new XDGField(xt.XB, "Test");
Random rand = new Random();
for (int i = 0; i < Test.CoordinateVector.Count; i++)
{
Test.CoordinateVector[i] = rand.NextDouble();
}
xt.agg.ClearAgglomerated(Test.CoordinateVector, Test.Mapping);
// do restriction/prolongation (Reference)
double[] RestVecRef = new double[XAggBasis.LocalDim];
XAggBasis.RestictFromFullGrid(Test.CoordinateVector, RestVecRef);
// and now with the matrix:
BlockMsrMatrix RestMtx = new BlockMsrMatrix(mgMap, mgMap.ProblemMapping);
XAggBasis.GetRestrictionMatrix(RestMtx, mgMap, 0);
double[] RestVec = new double[mgMap.LocalLength];
RestMtx.SpMV(1.0, Test.CoordinateVector, 0.0, RestVec);
double[] X1 = new double[xt.XdgMultigridOp.Mapping.LocalLength];
XDGField X2 = new XDGField(Test.Basis);
xt.XdgMultigridOp.TransformSolInto(Test.CoordinateVector, X1);
xt.XdgMultigridOp.TransformSolFrom(X2.CoordinateVector, X1);
//xt.agg.Extrapolate(X2.CoordinatesAsVector, X2.Mapping);
var ERR2 = Test.CloneAs();
ERR2.Acc(-1.0, X2);
double ERR2Norm = ERR2.L2Norm();
//Console.WriteLine("MultigridOperator TranformInto/FransformFrom mismatch: " + ERR2Norm);
Assert.LessOrEqual(ERR2Norm, 1.0e-8);
// compare
double ERR = 0.0;
int Nmax = XAggBasis.MaximalLength;
for (int jAgg = 0; jAgg < mgMap.AggGrid.iLogicalCells.NoOfLocalUpdatedCells; jAgg++)
{
int i0Ref = jAgg * Nmax;
int i0Tst = mgMap.LocalUniqueIndex(0, jAgg, 0);
int N = mgMap.GetLength(jAgg);
for (int n = 0; n < N; n++)
{
double dist = RestVecRef[i0Ref + n] - RestVec[i0Tst + n];
ERR += dist.Pow2();
}
}
Console.WriteLine("Restriction matrix test (iLevel = {0}): {1}", iLevel, ERR);
Assert.LessOrEqual(ERR, 1.0e-8);
//
double[] PrlgVecA = new double[XAggBasis.LocalDim];
double[] PrlgVecB = new double[mgMap.LocalLength];
for (int jAgg = 0; jAgg < mgMap.AggGrid.iLogicalCells.NoOfLocalUpdatedCells; jAgg++)
{
int i0Ref = jAgg * Nmax;
int i0Tst = mgMap.LocalUniqueIndex(0, jAgg, 0);
int N = mgMap.GetLength(jAgg);
for (int n = 0; n < N; n++)
{
double rndVal = rand.NextDouble();
PrlgVecA[i0Ref + n] = rndVal;
PrlgVecB[i0Tst + n] = rndVal;
}
}
XDGField QA = new XDGField(Test.Basis);
XDGField QB = new XDGField(Test.Basis);
XAggBasis.ProlongateToFullGrid(QA.CoordinateVector, PrlgVecA);
var PrlgMtx = RestMtx.Transpose();
PrlgMtx.SpMV(1.0, PrlgVecB, 0.0, QB.CoordinateVector);
XDGField ERR5 = QA.CloneAs();
ERR5.Acc(-1.0, QB);
double ERR5_Norm = ERR5.L2Norm();
Console.WriteLine("Prolongation matrix test (iLevel = {0}): {1}", iLevel, ERR5_Norm);
Assert.LessOrEqual(ERR5_Norm, 1.0e-8);
}
}
/// <summary>
/// Calculates the Torque around the center of mass
/// </summary>
/// <param name="U"></param>
/// <param name="P"></param>
/// <param name="momentFittingVariant"></param>
/// <param name="muA"></param>
/// <param name="particleRadius"></param>
/// <returns></returns>
static public void GetCellValues(VectorField <XDGField> U, XDGField P,
double muA, double particleRadius, SinglePhaseField P_atIB, SinglePhaseField gradU_atIB, SinglePhaseField gradUT_atIB)
{
var LsTrk = U[0].Basis.Tracker;
int D = LsTrk.GridDat.SpatialDimension;
var UA = U.Select(u => u.GetSpeciesShadowField("A")).ToArray();
if (D > 2)
{
throw new NotImplementedException("Currently only 2D cases supported");
}
int RequiredOrder = U[0].Basis.Degree * 3 + 2;
//if (RequiredOrder > agg.HMForder)
// throw new ArgumentException();
Console.WriteLine("Cell values calculated by: {0}, order = {1}", LsTrk.CutCellQuadratureType, RequiredOrder);
ConventionalDGField pA = null;
double circumference = new double();
pA = P.GetSpeciesShadowField("A");
for (int n = 0; n < 4; n++)
{
ScalarFunctionEx ErrFunc_CellVal = delegate(int j0, int Len, NodeSet Ns, MultidimensionalArray result) {
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray Grad_UARes = MultidimensionalArray.Create(Len, K, D, D);;
MultidimensionalArray pARes = MultidimensionalArray.Create(Len, K);
// Evaluate tangential velocity to level-set surface
var Normals = LsTrk.DataHistories[0].Current.GetLevelSetNormals(Ns, j0, Len);
for (int i = 0; i < D; i++)
{
UA[i].EvaluateGradient(j0, Len, Ns, Grad_UARes.ExtractSubArrayShallow(-1, -1, i, -1));
}
pA.Evaluate(j0, Len, Ns, pARes);
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
double acc2 = 0.0;
switch (n)
{
case 0: // Pressure part
acc += pARes[j, k] * Normals[j, k, 0];
acc *= -Normals[j, k, 1] * particleRadius;
acc2 += pARes[j, k] * Normals[j, k, 1];
acc2 *= Normals[j, k, 0] * particleRadius;
result[j, k] = acc + acc2;
break;
case 1: // GradU part
acc -= (1 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0]; // Attention was 2 times
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc *= -Normals[j, k, 1] * particleRadius;
acc2 -= (1 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc2 -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc2 *= Normals[j, k, 0] * particleRadius;
result[j, k] = acc + acc2;
break;
case 2: // GradU_T part
acc -= (1 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0]; // Attention was 2 times
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
acc *= -Normals[j, k, 1] * particleRadius;
acc2 -= (1 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1]; // Attention was 2 times
acc2 -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
acc2 *= Normals[j, k, 0] * particleRadius;
result[j, k] = acc + acc2;
break;
case 3: // Standardization with radians
result[j, k] = 1;
break;
default:
throw new NotImplementedException();
}
}
}
};
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper; // new XQuadSchemeHelper(LsTrk, momentFittingVariant, );
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, RequiredOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
ErrFunc_CellVal(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
switch (n)
{
case 0:
P_atIB.SetMeanValue(i0, ResultsOfIntegration[i, 0]);
break;
case 1:
gradU_atIB.SetMeanValue(i0, ResultsOfIntegration[i, 0]);
break;
case 2:
gradUT_atIB.SetMeanValue(i0, ResultsOfIntegration[i, 0]);
break;
case 3:
circumference += ResultsOfIntegration[i, 0];
P_atIB.SetMeanValue(i0, P_atIB.GetMeanValue(i0) / ResultsOfIntegration[i, 0]);
gradU_atIB.SetMeanValue(i0, gradU_atIB.GetMeanValue(i0) / ResultsOfIntegration[i, 0]);
gradUT_atIB.SetMeanValue(i0, gradUT_atIB.GetMeanValue(i0) / ResultsOfIntegration[i, 0]);
break;
default:
throw new NotImplementedException();
}
}
}
).Execute();
}
Console.WriteLine("Circle circumference: " + circumference);
}
public static void XDG_MatrixPolynomialRestAndPrlgTest_2(
[Values(0, 1, 2, 3)] int p,
[Values(0.0, 0.3)] double AggregationThreshold,
[Values(0, 1)] int TrackerWidth,
[Values(MultigridOperator.Mode.Eye, MultigridOperator.Mode.IdMass)] MultigridOperator.Mode mode)
{
if (AggregationThreshold < 0.1 && p >= 3 && mode == MultigridOperator.Mode.IdMass)
{
// this test combination is not supposed to work:
// without agglomeration, for high p, the mass matrix may be indefinite in small cut-cells
// => Cholesky decomposition on mass matrix fails, i.e. 'mode == IdMass' cannot succseed.
return;
}
XQuadFactoryHelper.MomentFittingVariants variant = XQuadFactoryHelper.MomentFittingVariants.OneStepGaussAndStokes;
var xt = new XDGTestSetup(p, AggregationThreshold, TrackerWidth, mode, variant);
// Restriction & prolongation together with orthonormalization
// -----------------------------------------------------------
for (var mgop = xt.MultigridOp; mgop != null; mgop = mgop.CoarserLevel)
{
var Itself = mgop.Mapping.FromOtherLevelMatrix(mgop.Mapping);
Itself.AccEyeSp(-1.0);
double Itslef_Norm = Itself.InfNorm();
//Console.WriteLine("Level {0}, Restriction onto itself {1}", mgm.LevelIndex, Itslef_Norm);
Assert.LessOrEqual(Itslef_Norm, 1.0e-8);
}
{
// test change of basis on top level
XDGField uTestRnd = new XDGField(xt.XB);
Random rnd = new Random();
for (int i = 0; i < uTestRnd.CoordinateVector.Count; i++)
{
uTestRnd.CoordinateVector[i] = rnd.NextDouble();
}
xt.agg.ClearAgglomerated(uTestRnd.CoordinateVector, uTestRnd.Mapping);
// perform change of basis on top level ...
int Ltop = xt.MultigridOp.Mapping.LocalLength;
double[] uTest_Fine = new double[Ltop];
xt.MultigridOp.TransformSolInto(uTestRnd.CoordinateVector, uTest_Fine);
// .. and back
XDGField uError2 = uTestRnd.CloneAs();
uError2.Clear();
xt.MultigridOp.TransformSolFrom(uError2.CoordinateVector, uTest_Fine);
// compare:
uError2.Acc(-1.0, uTestRnd);
double NORM_uError = uError2.L2Norm();
// output
Console.WriteLine("Top level change of basis error: {0}", NORM_uError);
Assert.LessOrEqual(NORM_uError, 1.0e-8);
}
{
// perform change of basis on top level
int Ltop = xt.MultigridOp.Mapping.LocalLength;
double[] uTest_Fine = new double[Ltop];
xt.MultigridOp.TransformSolInto(xt.uTest.CoordinateVector, uTest_Fine);
// check for each level of the multigrid operator...
for (int iLevel = 0; iLevel < MgSeq.Count() - 1; iLevel++)
{
double[] uTest_Prolonged = new double[Ltop];
XDG_Recursive(0, iLevel, xt.MultigridOp, uTest_Fine, uTest_Prolonged);
XDGField uError = xt.uTest.CloneAs();
uError.Clear();
xt.MultigridOp.TransformSolFrom(uError.CoordinateVector, uTest_Prolonged);
xt.agg.Extrapolate(uError.Mapping);
uError.Acc(-1.0, xt.uTest);
double NORM_uError = uError.L2Norm();
Console.WriteLine("Rest/Prlg error, level {0}: {1}", iLevel, NORM_uError);
Assert.LessOrEqual(NORM_uError, 1.0e-8);
}
}
}
public static double EnergyJumpAtInterface(LevelSetTracker LsTrk, VectorField <XDGField> Velocity, XDGField Pressure, double muA, double muB, bool Norm, int momentFittingorder)
{
double EnergyJump = 0.0;
ScalarFunctionEx EnergyJumpFunc = GetEnergyJumpFunc(LsTrk, Velocity, Pressure, muA, muB, Norm);
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
EnergyJumpFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
EnergyJump += ResultsOfIntegration[i, 0];
}
}
).Execute();
if (Norm)
{
EnergyJump.Sqrt();
}
return(EnergyJump);
}
public static ScalarFunctionEx GetEnergyJumpFunc(LevelSetTracker LsTrk, VectorField <XDGField> Velocity, XDGField Pressure, double muA, double muB, bool squared)
{
var UA = Velocity.Select(u => u.GetSpeciesShadowField("A")).ToArray();
var UB = Velocity.Select(u => u.GetSpeciesShadowField("B")).ToArray();
ConventionalDGField pA = null, pB = null;
bool UsePressure = Pressure != null;
if (UsePressure)
{
pA = Pressure.GetSpeciesShadowField("A");
pB = Pressure.GetSpeciesShadowField("B");
}
int D = LsTrk.GridDat.SpatialDimension;
ScalarFunctionEx EnergyJumpFunc = delegate(int j0, int Len, NodeSet Ns, MultidimensionalArray result) {
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray UA_res = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray UB_res = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray GradUA_res = MultidimensionalArray.Create(Len, K, D, D);
MultidimensionalArray GradUB_res = MultidimensionalArray.Create(Len, K, D, D);
MultidimensionalArray pA_res = MultidimensionalArray.Create(Len, K);
MultidimensionalArray pB_res = MultidimensionalArray.Create(Len, K);
for (int i = 0; i < D; i++)
{
UA[i].Evaluate(j0, Len, Ns, UA_res.ExtractSubArrayShallow(-1, -1, i));
UB[i].Evaluate(j0, Len, Ns, UB_res.ExtractSubArrayShallow(-1, -1, i));
UA[i].EvaluateGradient(j0, Len, Ns, GradUA_res.ExtractSubArrayShallow(-1, -1, i, -1));
UB[i].EvaluateGradient(j0, Len, Ns, GradUB_res.ExtractSubArrayShallow(-1, -1, i, -1));
}
if (UsePressure)
{
pA.Evaluate(j0, Len, Ns, pA_res);
pB.Evaluate(j0, Len, Ns, pB_res);
}
else
{
pA_res.Clear();
pB_res.Clear();
}
var Normals = LsTrk.DataHistories[0].Current.GetLevelSetNormals(Ns, j0, Len);
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
for (int d = 0; d < D; d++)
{
// pressure
if (UsePressure)
{
acc += (pB_res[j, k] * UB_res[j, k, d] - pA_res[j, k] * UA_res[j, k, d]) * Normals[j, k, d];
}
// Nabla U + (Nabla U) ^T
for (int dd = 0; dd < D; dd++)
{
acc -= (muB * GradUB_res[j, k, d, dd] * UB_res[j, k, dd] - muA * GradUA_res[j, k, d, dd] * UA_res[j, k, dd]) * Normals[j, k, d];
acc -= (muB * GradUB_res[j, k, dd, d] * UB_res[j, k, dd] - muA * GradUA_res[j, k, dd, d] * UA_res[j, k, dd]) * Normals[j, k, d]; // Transposed Term
}
}
if (squared)
{
result[j, k] = acc.Pow2();
}
else
{
result[j, k] = acc;
}
}
}
};
return(EnergyJumpFunc);
}
public static void ProjectEnergyBalanceNorm(this SinglePhaseField err, double alpha, XDGField P, VectorField <XDGField> U, ConventionalDGField[] Umean, SinglePhaseField C,
double muA, double muB, double sigma, int momentFittingOrder)
{
var LsTrk = U[0].Basis.Tracker;
int D = LsTrk.GridDat.SpatialDimension;
ScalarFunctionEx ErrFunc = GetEnergyBalanceFunc(P, U, Umean, C, muA, muB, sigma, true);
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingOrder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
ErrFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
err.SetMeanValue(i0 + i, ResultsOfIntegration[i, 0].Sqrt());
}
}
).Execute();
}
static ScalarFunctionEx GetEnergyBalanceFunc(XDGField P, VectorField <XDGField> U, ConventionalDGField[] Umean, SinglePhaseField C, double muA, double muB, double sigma, bool squared)
{
int D = P.Basis.GridDat.SpatialDimension;
ConventionalDGField pA = P.GetSpeciesShadowField("A");
ConventionalDGField pB = P.GetSpeciesShadowField("B");
var UA = U.Select(u => u.GetSpeciesShadowField("A")).ToArray();
var UB = U.Select(u => u.GetSpeciesShadowField("B")).ToArray();
return(delegate(int i0, int Len, NodeSet nds, MultidimensionalArray result) {
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray pA_res = MultidimensionalArray.Create(Len, K);
MultidimensionalArray pB_res = MultidimensionalArray.Create(Len, K);
MultidimensionalArray UA_res = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray UB_res = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray GradUA_res = MultidimensionalArray.Create(Len, K, D, D);
MultidimensionalArray GradUB_res = MultidimensionalArray.Create(Len, K, D, D);
MultidimensionalArray U_res = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray GradU_res = MultidimensionalArray.Create(Len, K, D, D);
MultidimensionalArray Curv_res = MultidimensionalArray.Create(Len, K);
pA.Evaluate(i0, Len, nds, pA_res);
pB.Evaluate(i0, Len, nds, pB_res);
for (int i = 0; i < D; i++)
{
UA[i].Evaluate(i0, Len, nds, UA_res.ExtractSubArrayShallow(-1, -1, i));
UB[i].Evaluate(i0, Len, nds, UB_res.ExtractSubArrayShallow(-1, -1, i));
Umean[i].Evaluate(i0, Len, nds, U_res.ExtractSubArrayShallow(-1, -1, i));
UA[i].EvaluateGradient(i0, Len, nds, GradUA_res.ExtractSubArrayShallow(-1, -1, i, -1));
UB[i].EvaluateGradient(i0, Len, nds, GradUB_res.ExtractSubArrayShallow(-1, -1, i, -1));
Umean[i].EvaluateGradient(i0, Len, nds, GradU_res.ExtractSubArrayShallow(-1, -1, i, -1));
}
C.Evaluate(i0, Len, nds, Curv_res);
var Normals = P.Basis.Tracker.DataHistories[0].Current.GetLevelSetNormals(nds, i0, Len);
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
for (int d = 0; d < D; d++)
{
// enrgy jump at interface
acc -= (pB_res[j, k] * UB_res[j, k, d] - pA_res[j, k] * UA_res[j, k, d]) * Normals[j, k, d];
for (int dd = 0; dd < D; dd++)
{
acc += (muB * GradUB_res[j, k, d, dd] * UB_res[j, k, dd] - muA * GradUA_res[j, k, d, dd] * UA_res[j, k, dd]) * Normals[j, k, d];
acc += (muB * GradUB_res[j, k, dd, d] * UB_res[j, k, dd] - muA * GradUA_res[j, k, dd, d] * UA_res[j, k, dd]) * Normals[j, k, d]; // Transposed Term
}
// surface energy changerate
//for (int dd = 0; dd < D; dd++) {
// if (dd == d) {
// acc += sigma * (1 - Normals[j, k, d] * Normals[j, k, dd]) * GradU_res[j, k, dd, d];
// } else {
// acc += sigma * (-Normals[j, k, d] * Normals[j, k, dd]) * GradU_res[j, k, dd, d];
// }
//}
// curvature energy
acc -= sigma * Curv_res[j, k] * U_res[j, k, d] * Normals[j, k, d];
}
if (squared)
{
result[j, k] = acc.Pow2();
}
else
{
result[j, k] = acc;
}
}
}
});
}
protected override void SetInitial()
{
base.SetInitial();
this.CreateEquationsAndSolvers(null);
if (this.Control.MultiStepInit == true)
{
int CallCount = 0;
if (m_RK_Timestepper != null)
{
throw new NotSupportedException();
}
m_BDF_Timestepper.MultiInit(0.0, 0, this.Control.GetFixedTimestep(),
delegate(int TimestepIndex, double Time, DGField[] St) {
Console.WriteLine("Timestep index {0}, time {1} ", TimestepIndex, Time);
// level-set
// ---------
this.Phi.ProjectField(X => this.Control.Phi(X, Time));
// HMF hacks
if ((this.Control.CircleRadius != null) != (this.Control.CutCellQuadratureType == XQuadFactoryHelper.MomentFittingVariants.ExactCircle))
{
throw new ApplicationException("Illegal HMF configuration.");
}
if (this.Control.CircleRadius != null)
{
ExactCircleLevelSetIntegration.RADIUS = new double[] { this.Control.CircleRadius(Time) };
}
if (CallCount == 0)
{
this.LsTrk.UpdateTracker();
}
else
{
this.LsTrk.UpdateTracker(incremental: true);
}
CallCount++;
// solution
// --------
XDGField _u = (XDGField)St[0];
_u.Clear();
_u.GetSpeciesShadowField("A").ProjectField((X => this.Control.uA_Ex(X, Time)));
_u.GetSpeciesShadowField("B").ProjectField((X => this.Control.uB_Ex(X, Time)));
});
}
else
{
this.Phi.ProjectField(X => this.Control.Phi(X, 0.0));
this.LsTrk.UpdateTracker();
u.Clear();
u.GetSpeciesShadowField("A").ProjectField((X => this.Control.uA_Ex(X, 0.0)));
u.GetSpeciesShadowField("B").ProjectField((X => this.Control.uB_Ex(X, 0.0)));
if (m_BDF_Timestepper != null)
{
m_BDF_Timestepper.SingleInit();
}
}
}
