public override double LevelSetForm(ref Foundation.XDG.CommonParamsLs cp, double[] U_Neg, double[] U_Pos, double[,] Grad_uA, double[,] Grad_uB, double vA, double vB, double[] Grad_vA, double[] Grad_vB) { double M = ComputeEvaporationMass(cp.ParamsNeg.GetSubVector(2 * D, D + 3), cp.ParamsPos.GetSubVector(2 * D, D + 3), cp.n, cp.jCell); if (M == 0.0) { return(0.0); } double[] VelocityMeanIn = new double[D]; double[] VelocityMeanOut = new double[D]; for (int d = 0; d < D; d++) { VelocityMeanIn[d] = cp.ParamsNeg[D + d]; VelocityMeanOut[d] = cp.ParamsPos[D + d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, cp.n, false); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, cp.n, false); double Lambda = Math.Max(LambdaIn, LambdaOut); double uJump = -M * ((1 / rhoA) - (1 / rhoB)) * cp.n[m_d]; double flx = Lambda * uJump * 0.8; return(-flx * (rhoA * vA - rhoB * vB)); }
public override double InnerEdgeForm(ref CommonParams cp, double[] U_Neg, double[] U_Pos, double[,] Grad_uA, double[,] Grad_uB, double vA, double vB, double[] Grad_vA, double[] Grad_vB) { double M = ComputeEvaporationMass(cp.Parameters_IN.GetSubVector(2 * m_D, m_D + 3), cp.Parameters_OUT.GetSubVector(2 * m_D, m_D + 3), cp.Normal, cp.jCellIn); if (M == 0.0) { return(0.0); } double[] VelocityMeanIn = new double[m_D]; double[] VelocityMeanOut = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanIn[d] = cp.Parameters_IN[m_D + d]; VelocityMeanOut[d] = cp.Parameters_OUT[m_D + d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, cp.Normal, false); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, cp.Normal, false); double Lambda = Math.Max(LambdaIn, LambdaOut); double uJump = -M * ((1 / m_rhoA) - (1 / m_rhoB)) * cp.Normal[m_d]; double flx = Lambda * uJump * 0.8; return(-flx * (m_rhoA * vA - m_rhoB * vB)); }
protected override double InnerEdgeFlux(ref CommonParams inp, double[] Uin, double[] Uout) { double r = 0.0; // Calculate central part // ====================== double rhoIn = 1.0; double rhoOut = 1.0; // 2 * {u_i * u_j} * n_j, // resp. 2 * {rho * u_i * u_j} * n_j for variable density r += rhoIn * Uin[0] * (inp.Parameters_IN[0] * inp.Normale[0] + inp.Parameters_IN[1] * inp.Normale[1]); r += rhoOut * Uout[0] * (inp.Parameters_OUT[0] * inp.Normale[0] + inp.Parameters_OUT[1] * inp.Normale[1]); if (m_SpatialDimension == 3) { r += rhoIn * Uin[0] * inp.Parameters_IN[2] * inp.Normale[2] + rhoOut * Uout[0] * inp.Parameters_OUT[2] * inp.Normale[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanIn = new double[m_SpatialDimension]; double[] VelocityMeanOut = new double[m_SpatialDimension]; for (int d = 0; d < m_SpatialDimension; d++) { VelocityMeanIn[d] = inp.Parameters_IN[m_SpatialDimension + d]; VelocityMeanOut[d] = inp.Parameters_OUT[m_SpatialDimension + d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, inp.Normale, true); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, inp.Normale, true); double Lambda = Math.Max(LambdaIn, LambdaOut); double uJump = Uin[0] - Uout[0]; r += Lambda * uJump * LaxFriedrichsSchemeSwitch; r *= 0.5; return(r); }
protected double InnerEdgeFlux_BaseCall(ref CommonParams inp, double[] Uin, double[] Uout) { double r = 0.0; // Calculate central part // ====================== r += inp.Parameters_IN[2 * m_SpatialDimension] * (inp.Parameters_IN[0] * inp.Normal[0] + inp.Parameters_IN[1] * inp.Normal[1]); r += inp.Parameters_OUT[2 * m_SpatialDimension] * (inp.Parameters_OUT[0] * inp.Normal[0] + inp.Parameters_OUT[1] * inp.Normal[1]); if (m_SpatialDimension == 3) { r += inp.Parameters_IN[2 * m_SpatialDimension] * inp.Parameters_IN[2] * inp.Normal[2] + inp.Parameters_OUT[2 * m_SpatialDimension] * inp.Parameters_OUT[2] * inp.Normal[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanIn = new double[m_SpatialDimension]; double[] VelocityMeanOut = new double[m_SpatialDimension]; for (int d = 0; d < m_SpatialDimension; d++) { VelocityMeanIn[d] = inp.Parameters_IN[m_SpatialDimension + d]; VelocityMeanOut[d] = inp.Parameters_OUT[m_SpatialDimension + d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, inp.Normal, true); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, inp.Normal, true); double Lambda = Math.Max(LambdaIn, LambdaOut); double uJump = inp.Parameters_IN[2 * m_SpatialDimension] - inp.Parameters_OUT[2 * m_SpatialDimension]; r += Lambda * uJump * LaxFriedrichsSchemeSwitch; r *= 0.5; return(r); }
protected override double InnerEdgeFlux(ref CommonParams inp, double[] Uin, double[] Uout) { double flux = 0; //Central Part flux += Uin[0] * (inp.Parameters_IN[0] * inp.Normale[0] + inp.Parameters_IN[1] * inp.Normale[1]); flux += Uout[0] * (inp.Parameters_OUT[0] * inp.Normale[0] + inp.Parameters_OUT[1] * inp.Normale[1]); if (D == 3) { flux += Uin[0] * inp.Parameters_IN[2] * inp.Normale[2] + Uout[0] * inp.Parameters_OUT[2] * inp.Normale[2]; } //Dissipative Part double[] VelocityMeanIn = new double[D]; double[] VelocityMeanOut = new double[D]; for (int d = 0; d < D; d++) { VelocityMeanIn[d] = inp.Parameters_IN[D + d]; VelocityMeanOut[d] = inp.Parameters_OUT[D + d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, inp.Normale, false); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, inp.Normale, false); double Lambda = Math.Max(LambdaIn, LambdaOut); double Scalar_Jump = Uin[0] - Uout[0]; flux += Lambda * Scalar_Jump; flux *= 0.5; return(flux); }
public double LevelSetForm(ref CommonParamsLs cp, double[] U_Neg, double[] U_Pos, double[,] Grad_uA, double[,] Grad_uB, double v_Neg, double v_Pos, double[] Grad_vA, double[] Grad_vB) { double[] U_NegFict, U_PosFict; this.TransformU(ref U_Neg, ref U_Pos, out U_NegFict, out U_PosFict); double[] ParamsNeg = cp.ParamsNeg; double[] ParamsPos = cp.ParamsPos; double[] ParamsPosFict, ParamsNegFict; this.TransformU(ref ParamsNeg, ref ParamsPos, out ParamsNegFict, out ParamsPosFict); //Flux for negativ side double FlxNeg; if (DirichletCond) { double r = 0.0; // Calculate central part // ====================== r += Tsat * (ParamsNeg[0] * cp.n[0] + ParamsNeg[1] * cp.n[1]); if (m_D == 3) { r += Tsat * ParamsNeg[2] * cp.n[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanIn = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanIn[d] = ParamsNeg[m_D + d]; } double LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, cp.n, true); double uJump = U_Neg[0] - Tsat; r += LambdaIn * uJump * LFFA; FlxNeg = capA * r; } else { BoSSS.Foundation.CommonParams inp; // = default(BoSSS.Foundation.InParams); inp.Parameters_IN = ParamsNeg; inp.Parameters_OUT = ParamsNegFict; inp.Normale = cp.n; inp.iEdge = int.MinValue; inp.GridDat = this.m_LsTrk.GridDat; inp.X = cp.x; inp.time = cp.time; FlxNeg = this.NegFlux.IEF(ref inp, U_Neg, U_NegFict); //Console.WriteLine("FlxNeg = {0}", FlxNeg); } // Flux for positive side double FlxPos; if (DirichletCond) { double r = 0.0; // Calculate central part // ====================== r += Tsat * (ParamsPos[0] * cp.n[0] + ParamsPos[1] * cp.n[1]); if (m_D == 3) { r += Tsat * ParamsPos[2] * cp.n[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanOut = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanOut[d] = ParamsPos[m_D + d]; } double LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, cp.n, true); double uJump = Tsat - U_Pos[0]; r += LambdaOut * uJump * LFFB; FlxPos = capB * r; } else { BoSSS.Foundation.CommonParams inp; // = default(BoSSS.Foundation.InParams); inp.Parameters_IN = ParamsPosFict; inp.Parameters_OUT = ParamsPos; inp.Normale = cp.n; inp.iEdge = int.MinValue; inp.GridDat = this.m_LsTrk.GridDat; inp.X = cp.x; inp.time = cp.time; FlxPos = this.PosFlux.IEF(ref inp, U_PosFict, U_Pos); //Console.WriteLine("FlxPos = {0}", FlxPos); } if (movingmesh) { return(0.0); } else { return(FlxNeg * v_Neg - FlxPos * v_Pos); } }
// Use Fluxes as in Bulk Convection //ConvectionInBulk_weightedLLF NegFlux; //ConvectionInBulk_weightedLLF PosFlux; //void TransformU(ref double[] U_Neg, ref double[] U_Pos, out double[] U_NegFict, out double[] U_PosFict) { // U_NegFict = U_Pos; // U_PosFict = U_Neg; //} public Double LevelSetForm(ref CommonParamsLs cp, double[] U_Neg, double[] U_Pos, double[,] Grad_uA, double[,] Grad_uB, double v_Neg, double v_Pos, double[] Grad_vA, double[] Grad_vB) { double UinBkUp = U_Neg[0]; double UoutBkUp = U_Pos[0]; double[] InParamsBkup = cp.ParamsNeg; double[] OutParamsBkup = cp.ParamsPos; // evaluate flux function // ---------------------- double flx = 0.0; double[] Uint = new double[] { 0.0, 0.0 }; // Calculate central part // ====================== //// 2 * {u_i * u_j} * n_j, //// resp. 2 * {rho * u_i * u_j} * n_j for variable density flx += rhoA * U_Neg[0] * ((cp.ParamsNeg[0] - Uint[0]) * cp.n[0] + (cp.ParamsNeg[1] - Uint[1]) * cp.n[1]); flx += rhoB * U_Pos[0] * ((cp.ParamsPos[0] - Uint[0]) * cp.n[0] + (cp.ParamsPos[1] - Uint[1]) * cp.n[1]); //if (m_D == 3) { // flx += rhoA * U_Neg[0] * cp.ParamsNeg[2] * cp.n[2] + rhoB * U_Pos[0] * cp.ParamsPos[2] * cp.n[2]; //} // Calculate dissipative part // ========================== double[] VelocityMeanIn = new double[m_D]; double[] VelocityMeanOut = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanIn[d] = cp.ParamsNeg[m_D + d] - Uint[d]; VelocityMeanOut[d] = cp.ParamsPos[m_D + d] - Uint[d]; } double LambdaIn; double LambdaOut; LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, cp.n, true); LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, cp.n, true); LambdaIn *= rhoA; LambdaOut *= rhoB; double Lambda = Math.Max(LambdaIn, LambdaOut); double uJump = U_Neg[0] - U_Pos[0]; flx += Lambda * uJump * LFF; flx *= 0.5; //flx *= rho_in; // cleanup mess and return // ----------------------- U_Pos[0] = UoutBkUp; U_Neg[0] = UinBkUp; cp.ParamsNeg = InParamsBkup; cp.ParamsPos = OutParamsBkup; // ==================================== double Flx = flx * v_Neg - flx * v_Pos; return(Flx); }
public double InnerEdgeForm(ref CommonParams cp, double[] U_Neg, double[] U_Pos, double[,] Grad_uA, double[,] Grad_uB, double v_Neg, double v_Pos, double[] Grad_vA, double[] Grad_vB) { double[] U_NegFict, U_PosFict; this.TransformU(ref U_Neg, ref U_Pos, out U_NegFict, out U_PosFict); double[] ParamsNeg = cp.Parameters_IN; double[] ParamsPos = cp.Parameters_OUT; double[] ParamsPosFict, ParamsNegFict; this.TransformU(ref ParamsNeg, ref ParamsPos, out ParamsNegFict, out ParamsPosFict); //Flux for negativ side double FlxNeg; if (!evapMicroRegion[cp.jCellIn]) { double r = 0.0; // Calculate central part // ====================== double Tavg = Tsat; // 0.5 * (U_Neg[0] + Tsat); r += Tavg * (ParamsNeg[0] * cp.Normal[0] + ParamsNeg[1] * cp.Normal[1]); if (m_D == 3) { r += Tavg * ParamsNeg[2] * cp.Normal[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanIn = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanIn[d] = ParamsNeg[m_D + d]; } double LambdaIn = LambdaConvection.GetLambda(VelocityMeanIn, cp.Normal, false); double uJump = U_Neg[0] - Tsat; r += LambdaIn * uJump * LFFA; FlxNeg = capA * r; } else { BoSSS.Foundation.CommonParams inp = cp; inp.Parameters_OUT = ParamsNegFict; FlxNeg = this.NegFlux.IEF(ref inp, U_Neg, U_NegFict); //Console.WriteLine("FlxNeg = {0}", FlxNeg); } // Flux for positive side double FlxPos; if (!evapMicroRegion[cp.jCellIn]) { double r = 0.0; // Calculate central part // ====================== double Tavg = Tsat; // 0.5 * (Tsat + U_Pos[0]); r += Tavg * (ParamsPos[0] * cp.Normal[0] + ParamsPos[1] * cp.Normal[1]); if (m_D == 3) { r += Tavg * ParamsPos[2] * cp.Normal[2]; } // Calculate dissipative part // ========================== double[] VelocityMeanOut = new double[m_D]; for (int d = 0; d < m_D; d++) { VelocityMeanOut[d] = ParamsPos[m_D + d]; } double LambdaOut = LambdaConvection.GetLambda(VelocityMeanOut, cp.Normal, false); double uJump = Tsat - U_Pos[0]; r += LambdaOut * uJump * LFFB; FlxPos = capB * r; } else { BoSSS.Foundation.CommonParams inp = cp; inp.Parameters_IN = ParamsPosFict; FlxPos = this.PosFlux.IEF(ref inp, U_PosFict, U_Pos); //Console.WriteLine("FlxPos = {0}", FlxPos); } if (movingmesh) { return(0.0); } else { return(FlxNeg * v_Neg - FlxPos * v_Pos); } }