protected override void InnerEdgeFlux(ref BoSSS.Foundation.CommonParams inp, double[] Uin, double[] Uout, out double FluxInCell, out double FluxOutCell)
{
double h_max = this.h_max_Edge[inp.iEdge];
double penalty = PressureStabilizationFactor * Reynolds * h_max;
FluxInCell = penalty * (Uin[0] - Uout[0]);
FluxOutCell = -FluxInCell;
}
protected override double InnerEdgeFlux(ref BoSSS.Foundation.CommonParams inp, double[] Uin, double[] Uout)
{
if (basecall)
{
return(base.InnerEdgeFlux(ref inp, Uin, Uout));
}
else
{
double UinBkUp = Uin[0];
double UoutBkUp = Uout[0];
double[] InParamsBkup = inp.Parameters_IN;
double[] OutParamsBkup = inp.Parameters_OUT;
// subgrid boundary handling
// -------------------------
if (inp.iEdge >= 0 && inp.jCellOut >= 0)
{
bool CellIn = SubGrdMask[inp.jCellIn];
bool CellOut = SubGrdMask[inp.jCellOut];
Debug.Assert(CellIn || CellOut, "at least one cell must be in the subgrid!");
if (CellOut == true && CellIn == false)
{
// IN-cell is outside of subgrid: extrapolate from OUT-cell!
Uin[0] = Uout[0];
inp.Parameters_IN = inp.Parameters_OUT.CloneAs();
}
if (CellIn == true && CellOut == false)
{
// ... and vice-versa
Uout[0] = Uin[0];
inp.Parameters_OUT = inp.Parameters_IN.CloneAs();
}
}
// evaluate flux function
// ----------------------
var flx = base.InnerEdgeFlux(ref inp, Uin, Uout);
flx *= rho;
// cleanup mess and return
// -----------------------
Uout[0] = UoutBkUp;
Uin[0] = UinBkUp;
inp.Parameters_IN = InParamsBkup;
inp.Parameters_OUT = OutParamsBkup;
return(flx);
}
}
public override double InnerEdgeForm(ref BoSSS.Foundation.CommonParams inp, double[] _uA, double[] _uB, double[,] _Grad_uA, double[,] _Grad_uB, double _vA, double _vB, double[] _Grad_vA, double[] _Grad_vB)
{
double Acc = 0.0;
double pnlty = this.penalty(inp.jCellIn, inp.jCellOut);//, inp.GridDat.Cells.cj);
double muA = this.Viscosity(inp.Parameters_IN);
double muB = this.Viscosity(inp.Parameters_OUT);
switch (base.m_implMode)
{
case ViscosityImplementation.H: //
{
for (int d = 0; d < inp.D; d++)
{
Acc += 0.5 * (muA * _Grad_uA[0, d] + muB * _Grad_uB[0, d]) * (_vA - _vB) * inp.Normale[d]; // consistency term
Acc += 0.5 * (muA * _Grad_vA[d] + muB * _Grad_vB[d]) * (_uA[0] - _uB[0]) * inp.Normale[d]; // symmetry term
//Acc += 0.5 * (muA * _Grad_uA[m_iComp, d] + muB * _Grad_uB[m_iComp, d]) * (_vA - _vB) * inp.Normale[d]; // consistency term
//Acc += 0.5 * (muA * _Grad_vA[d] + muB * _Grad_vB[d]) * (_uA[m_iComp] - _uB[m_iComp]) * inp.Normale[d]; // symmetry term
}
Acc *= base.m_alpha;
double muMax = (Math.Abs(muA) > Math.Abs(muB)) ? muA : muB;
Acc -= (_uA[0] - _uB[0]) * (_vA - _vB) * pnlty * muMax; // penalty term
//Acc -= (_uA[m_iComp] - _uB[m_iComp]) * (_vA - _vB) * pnlty * muMax; // penalty term
return(-Acc);
}
case ViscosityImplementation.SWIP: //
{
for (int d = 0; d < inp.D; d++)
{
Acc += (muB * muA * _Grad_uA[0, d] + muA * muB * _Grad_uB[0, d]) / (muA + muB) * (_vA - _vB) * inp.Normale[d]; // consistency term
Acc += (muB * muA * _Grad_vA[d] + muA * muB * _Grad_vB[d]) / (muA + muB) * (_uA[0] - _uB[0]) * inp.Normale[d]; // symmetry term
//Acc += (muB * muA * _Grad_uA[m_iComp, d] + muA * muB * _Grad_uB[m_iComp, d]) / (muA + muB) * (_vA - _vB) * inp.Normale[d]; // consistency term
//Acc += (muB * muA * _Grad_vA[d] + muA * muB * _Grad_vB[d]) / (muA + muB) * (_uA[m_iComp] - _uB[m_iComp]) * inp.Normale[d]; // symmetry term
}
Acc *= base.m_alpha;
Acc -= (_uA[0] - _uB[0]) * (_vA - _vB) * pnlty * (2 * muA * muB) / (muA + muB); // penalty term
//Acc -= (_uA[m_iComp] - _uB[m_iComp]) * (_vA - _vB) * pnlty * (2 * muA * muB) / (muA + muB); // penalty term
return(-Acc);
}
default:
throw new NotImplementedException();
}
}
internal double IEF(ref BoSSS.Foundation.CommonParams inp, double[] Uin, double[] Uout)
{
return(this.InnerEdgeFlux(ref inp, Uin, Uout));
}
protected override double InnerEdgeFlux(ref BoSSS.Foundation.CommonParams inp, double[] Uin, double[] Uout)
{
if (basecall)
{
return(base.InnerEdgeFlux(ref inp, Uin, Uout));
}
else
{
double UinBkUp = Uin[0];
double UoutBkUp = Uout[0];
double[] InParamsBkup = inp.Parameters_IN;
double[] OutParamsBkup = inp.Parameters_OUT;
int m_SpatialDimension = Uin.Length;
// subgrid boundary handling
// -------------------------
if (inp.iEdge >= 0 && inp.jCellOut >= 0)
{
bool CellIn = SubGrdMask[inp.jCellIn];
bool CellOut = SubGrdMask[inp.jCellOut];
Debug.Assert(CellIn || CellOut, "at least one cell must be in the subgrid!");
if (CellOut == true && CellIn == false)
{
// IN-cell is outside of subgrid: extrapolate from OUT-cell!
Uin[0] = Uout[0];
inp.Parameters_IN = inp.Parameters_OUT.CloneAs();
}
if (CellIn == true && CellOut == false)
{
// ... and vice-versa
Uout[0] = Uin[0];
inp.Parameters_OUT = inp.Parameters_IN.CloneAs();
}
}
// evaluate flux function
// ----------------------
double flx = 0.0;
// Calculate central part
// ======================
double rhoIn = 1.0;
// 2 * {u_i * u_j} * n_j,
// same as standard flux without outer values
flx += rhoIn * Uin[0] * (inp.Parameters_IN[0] * inp.Normale[0] + inp.Parameters_IN[1] * inp.Normale[1]);
if (m_SpatialDimension == 3)
{
flx += rhoIn * Uin[0] * inp.Parameters_IN[2] * inp.Normale[2];
}
// Calculate dissipative part
// ==========================
IList <double> _VelocityMeanIn = new List <double>();
IList <double> _VelocityMeanOut = new List <double>();
for (int d = 0; d < m_SpatialDimension; d++)
{
_VelocityMeanIn.Add(inp.Parameters_IN[m_SpatialDimension + d]);
_VelocityMeanOut.Add(inp.Parameters_OUT[m_SpatialDimension + d]);
}
double[] VelocityMeanIn = _VelocityMeanIn.ToArray();
double[] VelocityMeanOut = _VelocityMeanOut.ToArray();
flx *= base.rho;
// cleanup mess and return
// -----------------------
Uout[0] = UoutBkUp;
Uin[0] = UinBkUp;
inp.Parameters_IN = InParamsBkup;
inp.Parameters_OUT = OutParamsBkup;
return(flx);
}
}
