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());
}
public static double CurvatureEnergy(LevelSetTracker LsTrk, SinglePhaseField Curvature, double sigma, ConventionalDGField[] uI, bool ExtVel, bool Norm, int momentFittingorder)
{
double EnergyCurv = 0.0;
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
ScalarFunctionEx CurvEnergyFunc = GetCurvatureEnergyFunc(LsTrk, Curvature, sigma, uI, ExtVel, Norm);
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
CurvEnergyFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
EnergyCurv += ResultsOfIntegration[i, 0];
}
}
).Execute();
if (Norm)
{
EnergyCurv.Sqrt();
}
return(EnergyCurv);
}
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 static double SurfaceEnergyChangerate(LevelSetTracker LsTrk, ConventionalDGField[] uI, double sigma, bool Norm, int momentFittingorder)
{
double Changerate_Surface = 0.0;
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, momentFittingorder, 1).XQuadSchemeHelper;
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
ScalarFunctionEx SurfaceChangerate = GetInterfaceDivergenceFunc(LsTrk, uI, Norm);
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, momentFittingorder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
SurfaceChangerate(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
Changerate_Surface += ResultsOfIntegration[i, 0];
}
}
).Execute();
double Changerate_Esurf;
if (Norm)
{
Changerate_Esurf = sigma * Changerate_Surface.Sqrt();
}
else
{
Changerate_Esurf = sigma * Changerate_Surface;
}
return(Changerate_Esurf);
}
/// <summary>
/// ctor.
/// </summary>
public LxNormQuadrature(DGField owner, ScalarFunctionEx func, Func <double[], double, double, double> Map, ICompositeQuadRule <QuadRule> rule)
: base(new int[] { 1 }, owner.Basis.GridDat, rule) //
{
m_funcEx = func;
m_Owner = owner;
m_Map = Map;
}
/// <summary>
/// Evaluate a field at every single point of the (possibly sub-
/// divided) grid.
/// </summary>
/// <param name="Evaluator">The function to be evaluated</param>
/// <returns>
/// A list of results. See
/// <see cref="ScalarFunctionEx"/>
/// for information about the indexing.
/// </returns>
private MultidimensionalArray SampleField(ScalarFunctionEx Evaluator)
{
MultidimensionalArray result = MultidimensionalArray.Create(NoOfCells, verticesPerCell);
IEnumerable <Chunk> enumerable;
if (NoOfCells == sgrd.VolumeMask.NoOfItemsLocally)
{
enumerable = sgrd.VolumeMask;
}
else
{
enumerable = sgrd.VolumeMask.GetEnumerableWithExternal();
}
int iKref = Array.IndexOf(context.Grid.RefElements, this.Zone_Element);
foreach (var cnk in enumerable)
{
Evaluator(cnk.i0, cnk.Len, localVerticeCoordinates,
result.ExtractSubArrayShallow(new int[] { cnk.i0, 0 }, new int[] { cnk.JE - 1, verticesPerCell - 1 }));
}
return(result);
}
/// <summary>
/// creates a <see cref="ScalarFunctionEx"/> which represents the comosition
/// \f$ T \circ f\f$
/// </summary>
/// <param name="f">original function \f$ f\f$ </param>
/// <param name="T">transformation \f$ T\f$ </param>
/// <returns></returns>
static public ScalarFunctionEx Map(this ScalarFunctionEx f, Func <double, double> T)
{
return((new Map1()
{
T = T, f = f
}).Tf);
}
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);
}
protected override void CorrectLevelSet(int timestepNo, CellMask CellsToCorrect = null, bool ReIteration = false)
{
DGField Interface_old = Interface.CloneAs();
ScalarFunctionEx FrontTracking_LevelSetDistanceCorrectionFull = delegate(int cell0, int Len, NodeSet Ns, MultidimensionalArray result)
{
Interface_old.Evaluate(cell0, Len, Ns, result);
MultidimensionalArray GlobalNodes = this.Grid.GlobalNodes.GetValue_Cell(Ns, cell0, Len);
int c = 0;
for (int cell = cell0; cell < cell0 + Len; cell++, c++)
{
if (NarrowBandCells.Contains(cell))
//if(true)
{
for (int i = 0; i < Ns.NoOfNodes; i++)
{
MultidimensionalArray GlobalNode = MultidimensionalArray.Create(1, SpatialDimension);
for (int dim = 0; dim < SpatialDimension; dim++)
{
GlobalNode [0, dim] = GlobalNodes [c, i, dim];
}
double Phi_abs = AllEdges[0].SignedDistanceToPoint(GlobalNode);
foreach (Edge Edge in AllEdges)
{
double dist = Edge.SignedDistanceToPoint(GlobalNode);
if (Math.Abs(Phi_abs) > Math.Abs(dist))
{
Phi_abs = dist;
}
}
result[c, i] = Phi_abs;
}
}
else
{
for (int i = 0; i < Ns.NoOfNodes; i++)
{
if (result[c, i] > 0.0)
{
result[c, i] = 1;
}
else
{
result[c, i] = -1;
}
}
}
}
};
Interface.ProjectField(FrontTracking_LevelSetDistanceCorrectionFull);
}
/// <summary>
/// This call computes an integral measure which may depend on
/// this <see cref="DGField"/> an the given <paramref name="function"/>;
/// This is a collective call, it must be invoked by all
/// MPI processes within the communicator; internally, it invokes MPI_Allreduce;
/// </summary>
/// <param name="function"></param>
/// <param name="rule">
/// composite quadrature rule.
/// </param>
/// <param name="Map">
/// Arbiter mapping applied to the values of this field and
/// <paramref name="function"/> at some point, which is finally integrated.
/// E.g., the mapping for an L2-error would be \f$ (\vec{x},a,b) => (a - b)^2 \f$,
/// where \f$ a \f$ is the value of this field at some point \f$ \vec{x} \f$ and
/// \f$ b \f$ is the value of <paramref name="function"/> at \f$ \vec{x} \f$.
/// </param>
/// <returns>
/// on all invoking MPI processes, the L2 norm of
/// this field minus <paramref name="function"/>
/// </returns>
public double LxError(ScalarFunctionEx function, Func <double[], double, double, double> Map, ICompositeQuadRule <QuadRule> rule)
{
MPICollectiveWatchDog.Watch(csMPI.Raw._COMM.WORLD);
using (new FuncTrace()) {
LxNormQuadrature l2nq = new LxNormQuadrature(this, function, Map, rule);
l2nq.Execute();
double nrmtot = l2nq.LxNorm.MPISum();
return(nrmtot);
}
}
/// <summary>
/// Computes the Integral of a given function over the zero iso-contour of the Level-Set
/// </summary>
/// <param name="LsTrk">Level-Set tracker</param>
/// <param name="func">function which is integrated</param>
/// <param name="HMForder"></param>
/// <param name="spc">species, over whose surface is integrated</param>
/// <returns>Integral of <param name="func">func</param> over all MPI processors</returns>
static public double GetIntegralOverZeroLevelSet(LevelSetTracker LsTrk, ScalarFunctionEx func, int HMForder, SpeciesId spc)
{
using (new FuncTrace()) {
if (LsTrk.LevelSets.Count != 1)
{
throw new NotImplementedException();
}
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new SpeciesId[] { spc }, HMForder, 1).XQuadSchemeHelper;
// new XQuadSchemeHelper(LsTrk, momentFittingVariant);
// Classic HMF uses order+1 for Surface Integrals and additionally 1 order higher for the HMF system
// e.g order-2 is the cached quad rule
if (SchemeHelper.MomentFittingVariant == XQuadFactoryHelper.MomentFittingVariants.Classic)
{
HMForder -= 2;
}
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
double force = 0;
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, HMForder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
func(i0, Length, QR.Nodes, EvalResult);
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
force += ResultsOfIntegration[i, 0];
}
}
).Execute();
double localForce = force;
double globalForce;
unsafe
{
csMPI.Raw.Allreduce(
(IntPtr)(&localForce),
(IntPtr)(&globalForce),
1,
csMPI.Raw._DATATYPE.DOUBLE,
csMPI.Raw._OP.SUM,
csMPI.Raw._COMM.WORLD);
}
return(globalForce);
}
}
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);
}
}
}
public static ScalarFunctionEx GetCurvatureEnergyFunc(LevelSetTracker LsTrk, DGField Curvature, double sigma, ConventionalDGField[] uI, bool ExtVel, bool squared)
{
int D = LsTrk.GridDat.SpatialDimension;
ScalarFunctionEx CurvatureEnergyFunc = delegate(int i0, int Length, NodeSet nds, MultidimensionalArray result) {
Curvature.Evaluate(i0, Length, nds, result);
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray U_res = MultidimensionalArray.Create(Length, K, D);
for (int i = 0; i < D; i++)
{
uI.ElementAt(i).Evaluate(i0, Length, nds, U_res.ExtractSubArrayShallow(-1, -1, i));
}
var Normals = LsTrk.DataHistories[0].Current.GetLevelSetNormals(nds, i0, Length);
for (int j = 0; j < Length; j++)
{
for (int k = 0; k < K; k++)
{
double acc = result[j, k];
for (int d = 0; d < D; d++)
{
// U * N
if (!ExtVel)
{
acc *= U_res[j, k, d] * Normals[j, k, d];
}
else
{
acc *= U_res[j, k, d];
}
}
if (squared)
{
result[j, k] = (sigma * acc).Pow2();
}
else
{
result[j, k] = sigma * acc;
}
}
}
};
return(CurvatureEnergyFunc);
}
public static double GetKineticDissipation(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();
}
double dE = 0.0;
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 changerate_dEspc = GetSpeciesKineticDissipationFunc(Uspc, _mu);
CellQuadratureScheme vqs = SchemeHelper.GetVolumeQuadScheme(spcId);
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
vqs.Compile(LsTrk.GridDat, momentFittingOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
changerate_dEspc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
dE += ResultsOfIntegration[i, 0];
}
}
).Execute();
}
return(dE);
}
}
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();
}
public static double GetInterfaceShearViscosityEnergyCR(LevelSetTracker LsTrk, ConventionalDGField[] uI, double muI, int momentFittingOrder)
{
double shearViscEnergy = 0.0;
ScalarFunctionEx shearViscEnergyFunc = GetInterfaceShearViscosityEnergyCRFunc(LsTrk, uI, false);
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) {
shearViscEnergyFunc(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
shearViscEnergy += ResultsOfIntegration[i, 0];
}
}
).Execute();
return(muI * shearViscEnergy);
}
/// <summary>
/// Calculates the drag (x-component) and lift (y-component) forces acting on a wall of a boundary fitted grid
/// </summary>
/// <param name="U"></param>
/// <param name="P"></param>
/// <param name="muA"></param>
/// <returns></returns>
static public double[] GetForces_BoundaryFitted(VectorField <SinglePhaseField> GradU, VectorField <SinglePhaseField> GradV, SinglePhaseField StressXX,
SinglePhaseField StressXY, SinglePhaseField StressYY, SinglePhaseField P, LevelSetTracker LsTrk, double muA, double beta)
{
int D = LsTrk.GridDat.SpatialDimension;
if (D > 2)
{
throw new ArgumentException("Method GetForces_BoundaryFitted only implemented for 2D (viscoelastic)!");
}
// var UA = U.Select(u => u.GetSpeciesShadowField("A")).ToArray();
//var UA = U.ToArray();
MultidimensionalArray Grad_U = new MultidimensionalArray(D);
var _GradU = GradU.ToArray();
var _GradV = GradV.ToArray();
int RequiredOrder = _GradU[0].Basis.Degree * 3 + 2;
//int RequiredOrder = U[0].Basis.Degree * 3 + 2;
//int RequiredOrder = LsTrk.GetXQuadFactoryHelper(momentFittingVariant).GetCachedSurfaceOrders(0).Max();
//Console.WriteLine("Order reduction: {0} -> {1}", _RequiredOrder, RequiredOrder);
//if (RequiredOrder > agg.HMForder)
// throw new ArgumentException();
Console.WriteLine("Forces coeff: {0}, order = {1}", LsTrk.CutCellQuadratureType, RequiredOrder);
SinglePhaseField _StressXX = StressXX;
SinglePhaseField _StressXY = StressXY;
SinglePhaseField _StressYY = StressYY;
SinglePhaseField pA = null;
//pA = P.GetSpeciesShadowField("A");
pA = P;
double[] forces = new double[D];
for (int d = 0; d < D; d++)
{
ScalarFunctionEx ErrFunc = delegate(int j0, int Len, NodeSet Ns, MultidimensionalArray result) {
int K = result.GetLength(1); // No nof Nodes
MultidimensionalArray Grad_URes = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray Grad_VRes = MultidimensionalArray.Create(Len, K, D);
MultidimensionalArray pARes = MultidimensionalArray.Create(Len, K);
MultidimensionalArray StressXXRes = MultidimensionalArray.Create(Len, K);
MultidimensionalArray StressXYRes = MultidimensionalArray.Create(Len, K);
MultidimensionalArray StressYYRes = MultidimensionalArray.Create(Len, K);
var Normals = LsTrk.GridDat.Edges.NormalsCache.GetNormals_Edge(Ns, j0, Len);
//var Normals = MultidimensionalArray.Create(1, Ns.Length, 1);
//var Normals = LsTrk.GridDat.Edges.NormalsForAffine;
for (int i = 0; i < D; i++)
{
_GradU[i].EvaluateEdge(j0, Len, Ns, Grad_URes.ExtractSubArrayShallow(-1, -1, i),
Grad_URes.ExtractSubArrayShallow(-1, -1, i), ResultIndexOffset: 0, ResultPreScale: 1);
_GradV[i].EvaluateEdge(j0, Len, Ns, Grad_VRes.ExtractSubArrayShallow(-1, -1, i),
Grad_VRes.ExtractSubArrayShallow(-1, -1, i), ResultIndexOffset: 0, ResultPreScale: 1);
//UA[i].EvaluateGradient(j0, Len, Ns, Grad_UARes.ExtractSubArrayShallow(-1, -1, i, -1), 0, 1);
}
//pA.Evaluate(j0, Len, Ns, pARes);
pA.EvaluateEdge(j0, Len, Ns, pARes, pARes, ResultIndexOffset: 0, ResultPreScale: 1);
_StressXX.EvaluateEdge(j0, Len, Ns, StressXXRes, StressXXRes, ResultIndexOffset: 0, ResultPreScale: 1);
_StressXY.EvaluateEdge(j0, Len, Ns, StressXYRes, StressXYRes, ResultIndexOffset: 0, ResultPreScale: 1);
_StressYY.EvaluateEdge(j0, Len, Ns, StressYYRes, StressYYRes, ResultIndexOffset: 0, ResultPreScale: 1);
//if (LsTrk.GridDat.SpatialDimension == 2)
//{
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
// pressure
switch (d)
{
case 0:
acc += pARes[j, k] * Normals[j, k, 0];
acc -= (2 * muA * beta) * Grad_URes[j, k, 0] * Normals[j, k, 0];
acc -= (muA * beta) * Grad_URes[j, k, 1] * Normals[j, k, 1];
acc -= (muA * beta) * Grad_VRes[j, k, 0] * Normals[j, k, 1];
acc -= (muA * (1 - beta)) * StressXXRes[j, k] * Normals[j, k, 0];
acc -= (muA * (1 - beta)) * StressXYRes[j, k] * Normals[j, k, 1];
break;
case 1:
acc += pARes[j, k] * Normals[j, k, 1];
acc -= (2 * muA * beta) * Grad_VRes[j, k, 1] * Normals[j, k, 1];
acc -= (muA * beta) * Grad_VRes[j, k, 0] * Normals[j, k, 0];
acc -= (muA * beta) * Grad_URes[j, k, 1] * Normals[j, k, 0];
acc -= (muA * (1 - beta)) * StressXYRes[j, k] * Normals[j, k, 0];
acc -= (muA * (1 - beta)) * StressYYRes[j, k] * Normals[j, k, 1];
break;
default:
throw new NotImplementedException();
}
result[j, k] = acc;
}
}
//}
//else
//{
// for (int j = 0; j < Len; j++)
// {
// for (int k = 0; k < K; k++)
// {
// double acc = 0.0;
// // pressure
// switch (d)
// {
// case 0:
// acc += pARes[j, k] * Normals[j, k, 0];
// acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
// acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 2];
// acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
// acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
// acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 2];
// break;
// case 1:
// acc += pARes[j, k] * Normals[j, k, 1];
// acc -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
// acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 2];
// acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
// acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
// acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 2];
// break;
// case 2:
// acc += pARes[j, k] * Normals[j, k, 2];
// acc -= (2 * muA) * Grad_UARes[j, k, 2, 2] * Normals[j, k, 2];
// acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 0];
// acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 1];
// acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 0];
// acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 1];
// break;
// default:
// throw new NotImplementedException();
// }
// result[j, k] = acc;
//}
//}
//}
};
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper;
EdgeMask Mask = new EdgeMask(LsTrk.GridDat, "Wall_cylinder");
EdgeQuadratureScheme eqs = SchemeHelper.GetEdgeQuadScheme(LsTrk.GetSpeciesId("A"), IntegrationDomain: Mask);
EdgeQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
eqs.Compile(LsTrk.GridDat, RequiredOrder), // agg.HMForder),
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++)
{
forces[d] += ResultsOfIntegration[i, 0];
}
}
).Execute();
}
//for (int i = 0; i < D; i++)
// forces[i] = MPI.Wrappers.MPIExtensions.MPISum(forces[i]);
return(forces);
}
/// <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);
}
static public double[] GetParticleForces(VectorField <SinglePhaseField> U, SinglePhaseField P,
LevelSetTracker LsTrk,
double muA)
{
int D = LsTrk.GridDat.SpatialDimension;
// var UA = U.Select(u => u.GetSpeciesShadowField("A")).ToArray();
var UA = U.ToArray();
int RequiredOrder = U[0].Basis.Degree * 3 + 2;
//int RequiredOrder = LsTrk.GetXQuadFactoryHelper(momentFittingVariant).GetCachedSurfaceOrders(0).Max();
//Console.WriteLine("Order reduction: {0} -> {1}", _RequiredOrder, RequiredOrder);
//if (RequiredOrder > agg.HMForder)
// throw new ArgumentException();
Console.WriteLine("Forces coeff: {0}, order = {1}", LsTrk.CutCellQuadratureType, RequiredOrder);
ConventionalDGField pA = null;
//pA = P.GetSpeciesShadowField("A");
pA = P;
double[] forces = new double[D];
for (int d = 0; d < D; d++)
{
ScalarFunctionEx ErrFunc = 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), 0, 1);
}
pA.Evaluate(j0, Len, Ns, pARes);
if (LsTrk.GridDat.SpatialDimension == 2)
{
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
// pressure
switch (d)
{
case 0:
acc += pARes[j, k] * Normals[j, k, 0];
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
break;
case 1:
acc += pARes[j, k] * Normals[j, k, 1];
acc -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
break;
default:
throw new NotImplementedException();
}
result[j, k] = acc;
}
}
}
else
{
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
// pressure
switch (d)
{
case 0:
acc += pARes[j, k] * Normals[j, k, 0];
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 2];
break;
case 1:
acc += pARes[j, k] * Normals[j, k, 1];
acc -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 2];
break;
case 2:
acc += pARes[j, k] * Normals[j, k, 2];
acc -= (2 * muA) * Grad_UARes[j, k, 2, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 1];
break;
default:
throw new NotImplementedException();
}
result[j, k] = acc;
}
}
}
};
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper;
//var SchemeHelper = new XQuadSchemeHelper(LsTrk, momentFittingVariant, );
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, RequiredOrder), // agg.HMForder),
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++)
{
forces[d] += ResultsOfIntegration[i, 0];
}
}
).Execute();
}
for (int i = 0; i < D; i++)
{
forces[i] = MPI.Wrappers.MPIExtensions.MPISum(forces[i]);
}
return(forces);
}
/// <summary>
/// Calculates the Torque around the center of mass
/// </summary>
/// <param name="U"></param>
/// <param name="P"></param>
/// <param name="muA"></param>
/// <param name="particleRadius"></param>
/// <returns></returns>
static public double GetTorque(VectorField <SinglePhaseField> U, SinglePhaseField P,
LevelSetTracker LsTrk,
double muA, double particleRadius)
{
var _LsTrk = LsTrk;
int D = _LsTrk.GridDat.SpatialDimension;
var UA = U.ToArray();
//if (D > 2) throw new NotImplementedException("Currently only 2D cases supported");
int RequiredOrder = U[0].Basis.Degree * 3;
//if (RequiredOrder > agg.HMForder)
// throw new ArgumentException();
Console.WriteLine("Torque coeff: {0}, order = {1}", LsTrk.CutCellQuadratureType, RequiredOrder);
ConventionalDGField pA = null;
double force = new double();
pA = P;
ScalarFunctionEx ErrFunc = 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), 0, 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;
// Calculate the torque around a circular particle with a given radius (Paper Wan and Turek 2005)
acc += pARes[j, k] * Normals[j, k, 0];
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
acc *= -Normals[j, k, 1] * particleRadius;
acc2 += pARes[j, k] * Normals[j, k, 1];
acc2 -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc2 -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc2 -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
acc2 *= Normals[j, k, 0] * particleRadius;
result[j, k] = acc + acc2;
}
}
};
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper;
//var SchemeHelper = new XQuadSchemeHelper(_LsTrk, momentFittingVariant, _LsTrk.GetSpeciesId("A"));
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(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
force += ResultsOfIntegration[i, 0];
}
}
).Execute();
return(force);
}
/// <summary>
/// Evaluation of a function <paramref name="field"/> on the plotting grid
/// and optional averaging.
/// </summary>
/// <remarks>
/// The output is stored in members <see cref="smoothedResult"/> (if <see cref="showJumps"/>==false)
/// or <see cref="notSmoothedResult"/> (if <see cref="showJumps"/>==true).
/// </remarks>
protected void SampleField(ScalarFunctionEx field, bool showJumps)
{
MultidimensionalArray originalResult = SampleField(field);
if (showJumps)
{
notSmoothedResult = originalResult.Storage;
return;
}
smoothedResult = new double[totalVertices];
for (int i = 0; i < NoOfCells; i++)
{
for (int j = 0; j < verticesPerCell; j++)
{
smoothedResult[cellVertices[i, j]] += originalResult[i, j];
}
}
// If not in parallel, take a short cut
if (!parallelMode || (!showJumps && !ghostZone && parallelMode))
{
for (int i = 0; i < totalVertices; i++)
{
smoothedResult[i] /= multiplicity[i];
}
return;
}
int NoOfLocalCells = sgrd.LocalNoOfCells;
double[,] mySharedVerticesSmoothedResult = new double[maxLocalNoOfExternalCells, verticesPerCell];
for (int i = NoOfLocalCells; i < NoOfCells; i++)
{
int cellIndex = i - NoOfLocalCells;
for (int j = 0; j < verticesPerCell; j++)
{
mySharedVerticesSmoothedResult[cellIndex, j] = smoothedResult[cellVertices[i, j]];
}
}
double[,] result = new double[globalNoOfExternalCells, verticesPerCell];
double[,] sharedVerticesSmoothedResult = GatherGlobalSharedVerticesSmoothedResult(mySharedVerticesSmoothedResult, result);
for (int proc = 0; proc < noOfExternalCells.Length; proc++)
{
int start = maxLocalNoOfExternalCells * proc;
int end = maxLocalNoOfExternalCells * proc + noOfExternalCells[proc];
for (int i = 0; i < totalVertices; i++)
{
verticesAlreadyProcessed[i] = false;
}
for (int i = start; i < end; i++)
{
long localCell = sharedCellIndices[i] - context.CellPartitioning.i0;
if (localCell < 0 || localCell > NoOfLocalCells)
{
continue;
}
for (int j = 0; j < verticesPerCell; j++)
{
int localVertex = cellVertices[localCell, j];
if (verticesAlreadyProcessed[localVertex])
{
continue;
}
verticesAlreadyProcessed[localVertex] = true;
if (borderVertices.Contains(localVertex))
{
double newValue = sharedVerticesSmoothedResult[i, j];
double oldValue = smoothedResult[localVertex];
if (oldValue * oldValue < newValue * newValue)
{
smoothedResult[localVertex] = newValue;
}
}
}
}
}
for (int i = 0; i < totalVertices; i++)
{
smoothedResult[i] /= multiplicity[i];
}
}
/// <summary>
/// Update forces and torque acting from fluid onto the particle
/// </summary>
/// <param name="U"></param>
/// <param name="P"></param>
/// <param name="LsTrk"></param>
/// <param name="muA"></param>
public void UpdateForcesAndTorque(VectorField <SinglePhaseField> U, SinglePhaseField P,
LevelSetTracker LsTrk,
double muA)
{
if (skipForceIntegration)
{
skipForceIntegration = false;
return;
}
int D = LsTrk.GridDat.SpatialDimension;
// var UA = U.Select(u => u.GetSpeciesShadowField("A")).ToArray();
var UA = U.ToArray();
int RequiredOrder = U[0].Basis.Degree * 3 + 2;
//int RequiredOrder = LsTrk.GetXQuadFactoryHelper(momentFittingVariant).GetCachedSurfaceOrders(0).Max();
//Console.WriteLine("Order reduction: {0} -> {1}", _RequiredOrder, RequiredOrder);
//if (RequiredOrder > agg.HMForder)
// throw new ArgumentException();
Console.WriteLine("Forces coeff: {0}, order = {1}", LsTrk.CutCellQuadratureType, RequiredOrder);
ConventionalDGField pA = null;
//pA = P.GetSpeciesShadowField("A");
pA = P;
#region Force
double[] forces = new double[D];
for (int d = 0; d < D; d++)
{
ScalarFunctionEx ErrFunc = 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), 0, 1);
}
pA.Evaluate(j0, Len, Ns, pARes);
if (LsTrk.GridDat.SpatialDimension == 2)
{
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
// pressure
switch (d)
{
case 0:
acc += (pARes[j, k]) * Normals[j, k, 0];
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
break;
case 1:
acc += (pARes[j, k]) * Normals[j, k, 1];
acc -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
break;
default:
throw new NotImplementedException();
}
result[j, k] = acc;
}
}
}
else
{
for (int j = 0; j < Len; j++)
{
for (int k = 0; k < K; k++)
{
double acc = 0.0;
// pressure
switch (d)
{
case 0:
acc += pARes[j, k] * Normals[j, k, 0];
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 2];
break;
case 1:
acc += pARes[j, k] * Normals[j, k, 1];
acc -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 2];
break;
case 2:
acc += pARes[j, k] * Normals[j, k, 2];
acc -= (2 * muA) * Grad_UARes[j, k, 2, 2] * Normals[j, k, 2];
acc -= (muA) * Grad_UARes[j, k, 2, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 2, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 0, 2] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 1, 2] * Normals[j, k, 1];
break;
default:
throw new NotImplementedException();
}
result[j, k] = acc;
}
}
}
};
var SchemeHelper = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper;
//var SchemeHelper = new XQuadSchemeHelper(LsTrk, momentFittingVariant, );
//CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadratureScheme cqs = SchemeHelper.GetLevelSetquadScheme(0, this.cutCells_P(LsTrk));
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs.Compile(LsTrk.GridDat, RequiredOrder), // agg.HMForder),
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++)
{
forces[d] += ResultsOfIntegration[i, 0];
}
}
).Execute();
}
#endregion
#region Torque
double torque = 0;
ScalarFunctionEx ErrFunc2 = 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), 0, 1);
}
//var trafo = LsTrk.GridDat.Edges.Edge2CellTrafos;
//var trafoIdx = LsTrk.GridDat.TransformLocal2Global(Ns)
//var transFormed = trafo[trafoIdx].Transform(Nodes);
//var newVertices = transFormed.CloneAs();
//GridData.TransformLocal2Global(transFormed, newVertices, jCell);
MultidimensionalArray tempArray = Ns.CloneAs();
LsTrk.GridDat.TransformLocal2Global(Ns, tempArray, j0);
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;
// Calculate the torque around a circular particle with a given radius (Paper Wan and Turek 2005)
acc += (pARes[j, k] * Normals[j, k, 0]);
acc -= (2 * muA) * Grad_UARes[j, k, 0, 0] * Normals[j, k, 0];
acc -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 1];
acc -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 1];
//acc *= -Normals[j, k, 1] * this.radius_P;
acc *= -Normals[j, k, 1] * (this.currentPos_P[0][1] - tempArray[k, 1]).Abs();
acc2 += pARes[j, k] * Normals[j, k, 1];
acc2 -= (2 * muA) * Grad_UARes[j, k, 1, 1] * Normals[j, k, 1];
acc2 -= (muA) * Grad_UARes[j, k, 1, 0] * Normals[j, k, 0];
acc2 -= (muA) * Grad_UARes[j, k, 0, 1] * Normals[j, k, 0];
//acc2 *= Normals[j, k, 0] * this.radius_P;
acc2 *= Normals[j, k, 0] * (this.currentPos_P[0][0] - tempArray[k, 0]).Abs();
result[j, k] = acc + acc2;
}
}
};
var SchemeHelper2 = LsTrk.GetXDGSpaceMetrics(new[] { LsTrk.GetSpeciesId("A") }, RequiredOrder, 1).XQuadSchemeHelper;
//var SchemeHelper = new XQuadSchemeHelper(LsTrk, momentFittingVariant, );
//CellQuadratureScheme cqs2 = SchemeHelper2.GetLevelSetquadScheme(0, LsTrk.Regions.GetCutCellMask());
CellQuadratureScheme cqs2 = SchemeHelper2.GetLevelSetquadScheme(0, this.cutCells_P(LsTrk));
CellQuadrature.GetQuadrature(new int[] { 1 }, LsTrk.GridDat,
cqs2.Compile(LsTrk.GridDat, RequiredOrder),
delegate(int i0, int Length, QuadRule QR, MultidimensionalArray EvalResult) {
ErrFunc2(i0, Length, QR.Nodes, EvalResult.ExtractSubArrayShallow(-1, -1, 0));
},
delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) {
for (int i = 0; i < Length; i++)
{
torque += ResultsOfIntegration[i, 0];
}
}
).Execute();
double underrelaxationFT = 1.0;
double[] temp_underR = new double[D + 1];
for (int k = 0; k < D + 1; k++)
{
temp_underR[k] = underrelaxation_factor;
}
if (iteration_counter_P == 0)
{
underrelaxationFT = 1;
}
else if (underrelaxationFT_constant == true)
{
underrelaxationFT = underrelaxation_factor * Math.Pow(10, underrelaxationFT_exponent);
}
else if (underrelaxationFT_constant == false)
{
//double[] temp_underR = new double[D + 1];
bool underrelaxation_ok = false;
underrelaxationFT_exponent = 1;
for (int j = 0; j < D; j++)
{
underrelaxation_ok = false;
temp_underR[j] = underrelaxation_factor;
for (int i = 0; underrelaxation_ok == false; i++)
{
if (Math.Abs(temp_underR[j] * forces[j]) > Math.Abs(forces_P[0][j]))
{
underrelaxationFT_exponent -= 1;
temp_underR[j] = underrelaxation_factor * Math.Pow(10, underrelaxationFT_exponent);
}
else
{
underrelaxation_ok = true;
if (underrelaxationFT_exponent > -0)
{
underrelaxationFT_exponent = -0;
temp_underR[j] = underrelaxation_factor * Math.Pow(10, underrelaxationFT_exponent);
}
}
}
}
underrelaxation_ok = false;
temp_underR[D] = underrelaxation_factor;
for (int i = 0; underrelaxation_ok == false; i++)
{
if (Math.Abs(temp_underR[D] * torque) > Math.Abs(torque_P[0]))
{
underrelaxationFT_exponent -= 1;
temp_underR[D] = underrelaxation_factor * Math.Pow(10, underrelaxationFT_exponent);
}
else
{
underrelaxation_ok = true;
if (underrelaxationFT_exponent > -0)
{
underrelaxationFT_exponent = -0;
temp_underR[D] = underrelaxation_factor * Math.Pow(10, underrelaxationFT_exponent);
}
}
}
}
double[] forces_underR = new double[D];
for (int i = 0; i < D; i++)
{
forces_underR[i] = temp_underR[i] * forces[i] + (1 - temp_underR[i]) * forces_P[0][i];
}
double torque_underR = temp_underR[D] * torque + (1 - temp_underR[D]) * torque_P[0];
this.forces_P.Insert(0, forces_underR);
forces_P.Remove(forces_P.Last());
this.torque_P.Remove(torque_P.Last());
this.torque_P.Insert(0, torque_underR);
#endregion
}
/// <summary>
/// Correction of LevelSet with escaped particles.
/// First all particle are assigned with a recalculated level set phi
/// Then they are marked as escaped depending on their position in the level set DGField.
/// Finally a spherical local level set function is constructed around every escaped particle.
/// These functions are overlapped using the following rules:
/// For the plus(minus) particles the maximum(minimum) of the function is used.
/// Positiv and negative particles are overlapped by prioritizing the level set corrections that are nearer to the interface.
/// Method has to be called after the advection step but before the radius adjustment
/// </summary>
protected override void CorrectLevelSet(int timestepNo, CellMask CellsToCorrect = null, bool ReIteration = false)
{
DGField Interface_old = Interface.CloneAs();
ScalarFunctionEx Particle_LevelSetCorrection = delegate(int cell0, int Len, NodeSet Ns, MultidimensionalArray result)
{
Interface_old.Evaluate(cell0, Len, Ns, result);
MultidimensionalArray GlobalNodes = this.Grid.GlobalNodes.GetValue_Cell(Ns, cell0, Len);
int c = 0;
for (int cell = cell0; cell < cell0 + Len; cell++, c++)
{
if (NarrowBandCells.Contains(cell))
{
List <int> listindex = new List <int>();
if (CelltoArrayindex.ContainsKey(cell))
{
listindex.Add(cell);
}
Grid.GetCellNeighbours(cell, GetCellNeighbours_Mode.ViaVertices, out int[] NeighbourIndex, out int[] ConnectingEntities);
foreach (int j in NeighbourIndex)
{
if (CelltoArrayindex.ContainsKey(j))
{
listindex.Add(j);
}
}
if (listindex.IsNullOrEmpty())
{
continue;
}
for (int l = 0; l < listindex.Count; l++)
{
listindex[l] = CelltoArrayindex[listindex[l]];
}
for (int i = 0; i < Ns.NoOfNodes; i++)
{
Dictionary <int, double> Phi_correction = new Dictionary <int, double>
{
[-1] = result[c, i],
[1] = result[c, i]
};
if (MinimalDistanceSearch == MinimalDistanceSearchMode.FullSearch)
{
foreach (int index in listindex)
{
foreach (KeyValuePair <int, List <SingleLvlSetParticle> > DictEntry in Points[index].ItemList)
{
foreach (SingleLvlSetParticle SingleParticle in DictEntry.Value)
{
if (SingleParticle.Escaped == false || SingleParticle.Active == false)
{
continue;
}
double dist = 0;
for (int dim = 0; dim < SpatialDimension; dim++)
{
dist += (GlobalNodes[c, i, dim] - SingleParticle.Coordinates[0, dim]).Pow2();
}
dist = Math.Sqrt(dist);
double Phi_p = DictEntry.Key * (SingleParticle.Radius - dist);
Phi_correction[DictEntry.Key] = (DictEntry.Key * Phi_correction[DictEntry.Key] > DictEntry.Key * Phi_p)
? Phi_correction[DictEntry.Key] : Phi_p;
}
}
}
}
if (Math.Abs(Phi_correction[1]) <= Math.Abs(Phi_correction[-1]))
{
result[c, i] = Phi_correction[1];
}
else
{
result[c, i] = Phi_correction[-1];
}
}
}
else
{
for (int i = 0; i < Ns.NoOfNodes; i++)
{
if (result[c, i] > 0.0)
{
result[c, i] = 1;
}
else
{
result[c, i] = -1;
}
}
}
}
};
Interface.ProjectField(Particle_LevelSetCorrection);
}
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);
}
