protected override double BorderEdgeFlux(ref BoSSS.Foundation.CommonParamsBnd inp, double[] Uin)
{
this.basecall = true;
double flx = base.BorderEdgeFlux(ref inp, Uin);
this.basecall = false;
flx *= rho;
return(flx);
}
protected override bool IsDirichlet(ref BoSSS.Foundation.CommonParamsBnd inp)
{
IncompressibleBcType edgType = m_BcMap.EdgeTag2Type[inp.EdgeTag];
switch (edgType)
{
case IncompressibleBcType.Pressure_Outlet:
case IncompressibleBcType.Outflow:
return(true);
case IncompressibleBcType.Velocity_Inlet:
case IncompressibleBcType.Wall:
case IncompressibleBcType.NoSlipNeumann:
return(false);
default:
throw new NotImplementedException("unsupported/unknown b.c. - missing implementation;");
}
}
public override double BoundaryEdgeForm(ref BoSSS.Foundation.CommonParamsBnd inp, double[] _uA, double[,] _Grad_uA, double _vA, double[] _Grad_vA)
{
double Acc = 0.0;
double pnlty = 2 * this.penalty(inp.GridDat, inp.jCellIn, -1, inp.iEdge);//, inp.GridDat.Cells.cj);
double muA = this.Viscosity(inp.Parameters_IN);
IncompressibleBcType edgType = base.EdgeTag2Type[inp.EdgeTag];
switch (edgType)
{
case IncompressibleBcType.Velocity_Inlet:
case IncompressibleBcType.Wall:
case IncompressibleBcType.NoSlipNeumann: {
// inhom. Dirichlet b.c.
// +++++++++++++++++++++
double g_D = base.g_Diri(inp.X, inp.time, inp.EdgeTag, m_iComp);
//switch (base.m_implMode) {
// case ViscosityImplementation.H:
// case ViscosityImplementation.SWIP: {
for (int d = 0; d < inp.D; d++)
{
double nd = inp.Normal[d];
Acc += (muA * _Grad_uA[0, d]) * (_vA) * nd;
Acc += (muA * _Grad_vA[d]) * (_uA[0] - g_D) * nd;
//Acc += (muA * _Grad_uA[m_iComp, d]) * (_vA) * nd;
//Acc += (muA * _Grad_vA[d]) * (_uA[m_iComp] - g_D) * nd;
}
Acc *= base.m_alpha;
Acc -= muA * (_uA[0] - g_D) * (_vA - 0) * pnlty;
//Acc -= muA * (_uA[m_iComp] - g_D) * (_vA - 0) * pnlty;
// break;
// }
// default:
// throw new NotImplementedException();
//}
break;
}
case IncompressibleBcType.FreeSlip: {
//switch (base.m_implMode) {
// case ViscosityImplementation.H:
// case ViscosityImplementation.SWIP: {
// consistency
for (int d = 0; d < inp.D; d++)
{
Acc += (inp.Normal[m_iComp] * muA * _Grad_uA[0, d] * inp.Normal[d]) * (_vA * inp.Normal[m_iComp]) * base.m_alpha;
}
// penalty
Acc -= muA * (_uA[0] - 0) * inp.Normal[m_iComp] * inp.Normal[m_iComp] * (_vA - 0) * pnlty;
break;
// }
// default:
// throw new NotImplementedException();
//}
//break;
}
case IncompressibleBcType.NavierSlip_Linear: {
double[,] P = new double[inp.D, inp.D];
for (int d1 = 0; d1 < inp.D; d1++)
{
for (int d2 = 0; d2 < inp.D; d2++)
{
double nn = inp.Normal[d1] * inp.Normal[d2];
if (d1 == d2)
{
P[d1, d2] = 1 - nn;
}
else
{
P[d1, d2] = -nn;
}
}
}
double g_D = base.g_Diri(inp.X, inp.time, inp.EdgeTag, m_iComp);
//switch (base.m_implMode) {
// case ViscosityImplementation.H:
// case ViscosityImplementation.SWIP: {
for (int d = 0; d < inp.D; d++)
{
// consistency
Acc += muA * (inp.Normal[m_iComp] * _Grad_uA[0, d] * inp.Normal[d]) * (_vA * inp.Normal[m_iComp]);
// symmetry
Acc += muA * (inp.Normal[m_iComp] * _Grad_vA[d] * inp.Normal[d]) * (_uA[0] - g_D) * inp.Normal[m_iComp];
}
Acc *= base.m_alpha;
// penalty
Acc -= muA * ((_uA[0] - g_D) * inp.Normal[m_iComp]) * ((_vA - 0) * inp.Normal[m_iComp]) * pnlty;
// tangential dissipation force term
Acc -= (m_beta * P[0, m_iComp] * (_uA[0] - g_D)) * (P[0, m_iComp] * _vA) * base.m_alpha;
//for (int d = 0; d < inp.D; d++) {
// // no-penetration term
// Acc += (inp.Normale[m_iComp] * muA * _Grad_uA[0, d] * inp.Normale[d]) * (_vA * inp.Normale[m_iComp]) * base.m_alpha;
// // tangential dissipation force term
// Acc -= (m_beta * P[0, d] * (_uA[0] - g_D)) * (P[0, d] * _vA) * base.m_alpha;
//}
// break;
// }
//default:
// throw new NotImplementedException();
//}
break;
}
case IncompressibleBcType.Outflow:
case IncompressibleBcType.Pressure_Outlet: {
// Atmospheric outlet/pressure outflow: hom. Neumann
// +++++++++++++++++++++++++++++++++++++++++++++++++
double g_N = g_Neu(inp.X, inp.Normal, inp.EdgeTag);
//switch (base.m_implMode) {
// case ViscosityImplementation.H:
// case ViscosityImplementation.SWIP: {
Acc += muA * g_N * _vA * base.m_alpha;
break;
// }
// default:
// throw new NotImplementedException();
//}
//break;
}
case IncompressibleBcType.Pressure_Dirichlet: {
// Dirichlet boundary condition for pressure.
// Inner values of velocity gradient are taken, i.e.
// no boundary condition for the velocity (resp. velocity gradient) is imposed.
//switch (base.m_implMode) {
// case ViscosityImplementation.H:
// case ViscosityImplementation.SWIP: {
for (int d = 0; d < inp.D; d++)
{
Acc += (muA * _Grad_uA[0, d]) * (_vA) * inp.Normal[d];
//Acc += (muA * _Grad_uA[m_iComp, d]) * (_vA) * inp.Normale[d];
}
Acc *= base.m_alpha;
// break;
// }
// default:
// throw new NotImplementedException();
//}
break;
}
default:
throw new NotImplementedException();
}
return(-Acc);
}
protected override void BorderEdgeFlux_(ref BoSSS.Foundation.CommonParamsBnd inp, double[] Uin, out double FluxInCell)
{
FluxInCell = 0.0;
}
