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); } }