//==============================================================
// additional interface components for NSFE interface components
//==============================================================
/// <summary>
///
/// </summary>
/// <param name="XOp"></param>
/// <param name="config"></param>
/// <param name="d"></param>
/// <param name="D"></param>
/// <param name="LsTrk"></param>
public static void AddInterfaceNSE_withEvaporation_component(XSpatialOperatorMk2 XOp, XNSFE_OperatorConfiguration config,
int d, int D, LevelSetTracker LsTrk)
{
// check input
if (XOp.IsCommited)
{
throw new InvalidOperationException("Spatial Operator is already comitted. Adding of new components is not allowed");
}
string CodName = EquationNames.MomentumEquationComponent(d);
if (!XOp.CodomainVar.Contains(CodName))
{
throw new ArgumentException("CoDomain variable \"" + CodName + "\" is not defined in Spatial Operator");
}
PhysicalParameters physParams = config.getPhysParams;
ThermalParameters thermParams = config.getThermParams;
DoNotTouchParameters dntParams = config.getDntParams;
double sigma = physParams.Sigma;
// set components
var comps = XOp.EquationComponents[CodName];
if (config.isTransport)
{
comps.Add(new ConvectionAtLevelSet_nonMaterialLLF(d, D, LsTrk, thermParams, sigma));
comps.Add(new ConvectionAtLevelSet_Consistency(d, D, LsTrk, dntParams.ContiSign, dntParams.RescaleConti, thermParams, sigma));
}
if (config.isMovingMesh)
{
comps.Add(new ConvectionAtLevelSet_MovingMesh(d, D, LsTrk, thermParams, sigma));
}
if (config.isViscous)
{
comps.Add(new ViscosityAtLevelSet_FullySymmetric_withEvap(LsTrk, physParams.mu_A, physParams.mu_B, dntParams.PenaltySafety, d, thermParams, sigma));
}
comps.Add(new MassFluxAtInterface(d, D, LsTrk, thermParams, sigma));
}
//==============================================================
// additional interface components for NSFE interface components
//==============================================================
/// <summary>
///
/// </summary>
/// <param name="XOp"></param>
/// <param name="config"></param>
/// <param name="d"></param>
/// <param name="D"></param>
/// <param name="LsTrk"></param>
public static void AddInterfaceNSE_withEvaporation_component(XSpatialOperatorMk2 XOp, XNSFE_OperatorConfiguration config,
int d, int D, LevelSetTracker LsTrk)
{
// check input
if (XOp.IsCommited)
{
throw new InvalidOperationException("Spatial Operator is already comitted. Adding of new components is not allowed");
}
string CodName = EquationNames.MomentumEquationComponent(d);
if (!XOp.CodomainVar.Contains(CodName))
{
throw new ArgumentException("CoDomain variable \"" + CodName + "\" is not defined in Spatial Operator");
}
PhysicalParameters physParams = config.getPhysParams;
ThermalParameters thermParams = config.getThermParams;
DoNotTouchParameters dntParams = config.getDntParams;
// set species arguments
double rhoA = physParams.rho_A;
double rhoB = physParams.rho_B;
double muA = physParams.mu_A;
double muB = physParams.mu_B;
double sigma = physParams.Sigma;
// compute further arguments
double hVapA = thermParams.hVap_A;
double hVapB = thermParams.hVap_B;
double Tsat = thermParams.T_sat;
double f = config.thermParams.fc;
double R = config.thermParams.Rc;
double R_int = 0.0;
if (config.thermParams.hVap_A > 0 && config.thermParams.hVap_B < 0)
{
R_int = ((2.0 - f) / (2 * f)) * Tsat * Math.Sqrt(2 * Math.PI * R * Tsat) / (rhoB * hVapA.Pow2());
//T_intMin = Tsat * (1 + (pc / (rhoA * hVapA.Pow2())));
}
else if (config.thermParams.hVap_A < 0 && config.thermParams.hVap_B > 0)
{
R_int = ((2.0 - f) / (2 * f)) * Tsat * Math.Sqrt(2 * Math.PI * R * Tsat) / (rhoA * hVapB.Pow2());
//T_intMin = Tsat * (1 + (pc / (rhoB * hVapB.Pow2())));
}
//double prescrbM = config.prescribedMassflux;
// set components
var comps = XOp.EquationComponents[CodName];
if (config.isTransport)
{
comps.Add(new ConvectionAtLevelSet_nonMaterialLLF(d, D, LsTrk, rhoA, rhoB, thermParams, R_int, sigma));
comps.Add(new ConvectionAtLevelSet_Consistency(d, D, LsTrk, rhoA, rhoB, dntParams.ContiSign, dntParams.RescaleConti, thermParams, R_int, sigma));
}
//if (config.isPInterfaceSet) {
// comps.Add(new GeneralizedPressureFormAtLevelSet(d, LsTrk, thermParams.p_sat, thermParams.hVap_A));
//}
if (config.isViscous)
{
comps.Add(new ViscosityAtLevelSet_FullySymmetric_withEvap(LsTrk, muA, muB, dntParams.PenaltySafety, d, rhoA, rhoB, thermParams, R_int, sigma));
}
comps.Add(new MassFluxAtInterface(d, D, LsTrk, rhoA, rhoB, thermParams, R_int, sigma));
}
//=======================
// Navier Stokes equation
//=======================
#region nse
/// <summary>
///
/// </summary>
/// <param name="XOp"></param>
/// <param name="d"></param>
/// <param name="D"></param>
/// <param name="spcName"></param>
/// <param name="spcId"></param>
/// <param name="BcMap"></param>
/// <param name="config"></param>
/// <param name="LsTrk"></param>
/// <param name="U0meanrequired"></param>
public static void AddSpeciesNSE_component(XSpatialOperatorMk2 XOp, INSE_Configuration config, int d, int D, string spcName, SpeciesId spcId,
IncompressibleMultiphaseBoundaryCondMap BcMap, LevelSetTracker LsTrk, out bool U0meanrequired)
{
// check input
if (XOp.IsCommited)
{
throw new InvalidOperationException("Spatial Operator is already committed. Adding of new components is not allowed");
}
string CodName = EquationNames.MomentumEquationComponent(d);
if (!XOp.CodomainVar.Contains(CodName))
{
throw new ArgumentException("CoDomain variable \"" + CodName + "\" is not defined in Spatial Operator");
}
PhysicalParameters physParams = config.getPhysParams;
DoNotTouchParameters dntParams = config.getDntParams;
// set species arguments
double rhoSpc, LFFSpc, muSpc;
switch (spcName)
{
case "A": { rhoSpc = physParams.rho_A; LFFSpc = dntParams.LFFA; muSpc = physParams.mu_A; break; }
case "B": { rhoSpc = physParams.rho_B; LFFSpc = dntParams.LFFB; muSpc = physParams.mu_B; break; }
default: throw new ArgumentException("Unknown species.");
}
// set components
var comps = XOp.EquationComponents[CodName];
// convective operator
// ===================
U0meanrequired = false;
if (physParams.IncludeConvection && config.isTransport)
{
var conv = new Operator.Convection.ConvectionInSpeciesBulk_LLF(D, BcMap, spcName, spcId, d, rhoSpc, LFFSpc, LsTrk);
comps.Add(conv);
U0meanrequired = true;
}
// pressure gradient
// =================
if (config.isPressureGradient)
{
var pres = new Operator.Pressure.PressureInSpeciesBulk(d, BcMap, spcName, spcId);
comps.Add(pres);
//problably necessary for LDG Simulation. Only one species parameter reynoldsA!!!!!!
//var presStab = new PressureStabilizationInBulk(dntParams.PresPenalty2, physParams.reynolds_A, spcName, spcId);
//comps.Add(presStab);
}
// viscous operator
// ================
if (config.isViscous && !(muSpc == 0.0))
{
double penalty = dntParams.PenaltySafety;
switch (dntParams.ViscosityMode)
{
case ViscosityMode.Standard:
case ViscosityMode.TransposeTermMissing: {
// Bulk operator:
var Visc1 = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
comps.Add(Visc1);
if (dntParams.UseGhostPenalties)
{
var Visc1Penalty = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUTerm(
penalty, 0.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
XOp.GhostEdgesOperator.EquationComponents[CodName].Add(Visc1Penalty);
}
break;
}
case ViscosityMode.FullySymmetric: {
// Bulk operator
var Visc1 = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
comps.Add(Visc1);
var Visc2 = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUtranspTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
comps.Add(Visc2);
if (dntParams.UseGhostPenalties)
{
var Visc1Penalty = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUTerm(
penalty, 0.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
var Visc2Penalty = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUtranspTerm(
penalty, 0.0,
BcMap, spcName, spcId, d, D, physParams.mu_A, physParams.mu_B);
XOp.GhostEdgesOperator.EquationComponents[CodName].Add(Visc1Penalty);
XOp.GhostEdgesOperator.EquationComponents[CodName].Add(Visc2Penalty);
}
break;
}
case ViscosityMode.Viscoelastic: {
//set species arguments
double ReSpc, betaSpc;
switch (spcName)
{
case "A": { ReSpc = physParams.reynolds_A; betaSpc = physParams.beta_a; break; }
case "B": { ReSpc = physParams.reynolds_B; betaSpc = physParams.beta_b; break; }
default: throw new ArgumentException("Unknown species.");
}
// Bulk operator:
var Visc1 = new Operator.Viscosity.DimensionlessViscosityInSpeciesBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, spcName, spcId, d, D, physParams.reynolds_A / physParams.beta_a, physParams.reynolds_B / physParams.beta_b);
comps.Add(Visc1);
var Visc2 = new Operator.Viscosity.DimensionlessViscosityInSpeciesBulk_GradUtranspTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, spcName, spcId, d, D, physParams.reynolds_A / physParams.beta_a, physParams.reynolds_B / physParams.beta_b);
comps.Add(Visc2);
var div = new StressDivergenceInBulk(d, BcMap, ReSpc, dntParams.Penalty1, dntParams.Penalty2, spcName, spcId);
comps.Add(div);
break;
}
default:
throw new NotImplementedException();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="XOp"></param>
/// <param name="config"></param>
/// <param name="d"></param>
/// <param name="D"></param>
/// <param name="BcMap"></param>
/// <param name="LsTrk"></param>
/// <param name="degU"></param>
/// <param name="NormalsRequired"></param>
/// <param name="CurvatureRequired"></param>
public static void AddSurfaceTensionForce_component(XSpatialOperatorMk2 XOp, IXNSE_Configuration config, int d, int D,
IncompressibleMultiphaseBoundaryCondMap BcMap, LevelSetTracker LsTrk, int degU,
out bool NormalsRequired, out bool CurvatureRequired)
{
// check input
if (XOp.IsCommited)
{
throw new InvalidOperationException("Spatial Operator is already comitted. Adding of new components is not allowed");
}
string CodName = EquationNames.MomentumEquationComponent(d);
if (!XOp.CodomainVar.Contains(CodName))
{
throw new ArgumentException("CoDomain variable \"" + CodName + "\" is not defined in Spatial Operator");
}
PhysicalParameters physParams = config.getPhysParams;
DoNotTouchParameters dntParams = config.getDntParams;
// set arguments
double sigma = physParams.Sigma;
// set components
//var comps = XOp.SurfaceElementOperator.EquationComponents[CodName];
// surface stress tensor
// =====================
NormalsRequired = false;
CurvatureRequired = false;
if (config.isPressureGradient && physParams.Sigma != 0.0)
{
// isotropic part of the surface stress tensor
// ===========================================
if (dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Flux ||
dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Local ||
dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_ContactLine)
{
if (dntParams.SST_isotropicMode != SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_ContactLine)
{
IEquationComponent G = new SurfaceTension_LaplaceBeltrami_Surface(d, sigma * 0.5);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(G);
IEquationComponent H = new SurfaceTension_LaplaceBeltrami_BndLine(d, sigma * 0.5, dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Flux);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(H);
}
else
{
IEquationComponent isoSurfT = new IsotropicSurfaceTension_LaplaceBeltrami(d, D, sigma * 0.5, BcMap.EdgeTag2Type, BcMap, physParams.theta_e, physParams.betaL);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(isoSurfT);
}
NormalsRequired = true;
}
else if (dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_Projected ||
dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_ClosestPoint ||
dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_LaplaceBeltramiMean ||
dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_Fourier)
{
XOp.EquationComponents[CodName].Add(new CurvatureBasedSurfaceTension(d, D, LsTrk, sigma));
CurvatureRequired = true;
}
else
{
throw new NotImplementedException("Not implemented.");
}
// dynamic part of the surface stress tensor
// =========================================
if (dntParams.SurfStressTensor != SurfaceSressTensor.Isotropic)
{
double muI = physParams.mu_I;
double lamI = physParams.lambda_I;
double lamI_t = (physParams.lambdaI_tilde < 0) ? (lamI - muI) : physParams.lambdaI_tilde;
double penalty_base = (degU + 1) * (degU + D) / D;
double penalty = penalty_base * dntParams.PenaltySafety;
// surface dilatational viscosity
if (dntParams.SurfStressTensor == SurfaceSressTensor.SurfaceDivergence ||
dntParams.SurfStressTensor == SurfaceSressTensor.FullBoussinesqScriven)
{
var surfDiv = new BoussinesqScriven_SurfaceVelocityDivergence(d, D, lamI_t * 0.5, penalty, BcMap.EdgeTag2Type, true);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(surfDiv);
}
// surface shear viscosity
if (dntParams.SurfStressTensor == SurfaceSressTensor.SurfaceRateOfDeformation ||
dntParams.SurfStressTensor == SurfaceSressTensor.SemiImplicit ||
dntParams.SurfStressTensor == SurfaceSressTensor.FullBoussinesqScriven)
{
var surfDeformRate = new BoussinesqScriven_SurfaceDeformationRate_GradU(d, D, muI * 0.5, penalty, true, dntParams.SurfStressTensor == SurfaceSressTensor.SemiImplicit);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(surfDeformRate);
if (dntParams.SurfStressTensor != SurfaceSressTensor.SemiImplicit)
{
var surfDeformRateT = new BoussinesqScriven_SurfaceDeformationRate_GradUTranspose(d, D, muI * 0.5, penalty, true);
XOp.SurfaceElementOperator.EquationComponents[CodName].Add(surfDeformRateT);
}
}
}
// stabilization
// =============
if (dntParams.UseLevelSetStabilization)
{
XOp.EquationComponents[CodName].Add(new LevelSetStabilization(d, D, LsTrk));
}
}
// artificial surface tension force
// ================================
if (config.isPressureGradient && physParams.useArtificialSurfaceForce)
{
XOp.EquationComponents[CodName].Add(new SurfaceTension_ArfForceSrc(d, D, LsTrk));
}
}
/// <summary>
///
/// </summary>
/// <param name="XOp"></param>
/// <param name="config"></param>
/// <param name="d"></param>
/// <param name="D"></param>
/// <param name="BcMap"></param>
/// <param name="LsTrk"></param>
public static void AddInterfaceNSE_component(XSpatialOperatorMk2 XOp, IXNSE_Configuration config, int d, int D,
IncompressibleMultiphaseBoundaryCondMap BcMap, LevelSetTracker LsTrk)
{
// check input
if (XOp.IsCommited)
{
throw new InvalidOperationException("Spatial Operator is already comitted. Adding of new components is not allowed");
}
string CodName = EquationNames.MomentumEquationComponent(d);
if (!XOp.CodomainVar.Contains(CodName))
{
throw new ArgumentException("CoDomain variable \"" + CodName + "\" is not defined in Spatial Operator");
}
PhysicalParameters physParams = config.getPhysParams;
DoNotTouchParameters dntParams = config.getDntParams;
// set species arguments
double rhoA = physParams.rho_A;
double rhoB = physParams.rho_B;
double LFFA = dntParams.LFFA;
double LFFB = dntParams.LFFB;
double muA = physParams.mu_A;
double muB = physParams.mu_B;
//viscoelastic
double reynoldsA = physParams.reynolds_A;
double reynoldsB = physParams.reynolds_B;
double betaA = physParams.beta_a;
double betaB = physParams.beta_b;
double[] penalty1 = dntParams.Penalty1;
double penalty2 = dntParams.Penalty2;
// set components
var comps = XOp.EquationComponents[CodName];
// convective operator
// ===================
if (physParams.IncludeConvection && config.isTransport)
{
var conv = new Operator.Convection.ConvectionAtLevelSet_LLF(d, D, LsTrk, rhoA, rhoB, LFFA, LFFB, physParams.Material, BcMap, config.isMovingMesh);
comps.Add(conv);
}
// pressure gradient
// =================
if (config.isPressureGradient)
{
var presLs = new Operator.Pressure.PressureFormAtLevelSet(d, D, LsTrk);
comps.Add(presLs);
}
// viscous operator
// ================
if (config.isViscous && (!(muA == 0.0) && !(muB == 0.0)))
{
double penalty = dntParams.PenaltySafety;
switch (dntParams.ViscosityMode)
{
case ViscosityMode.Standard:
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_Standard(LsTrk, muA, muB, penalty * 1.0, d, true));
break;
case ViscosityMode.TransposeTermMissing:
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_Standard(LsTrk, muA, muB, penalty * 1.0, d, false));
break;
case ViscosityMode.FullySymmetric:
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_FullySymmetric(LsTrk, muA, muB, penalty, d, dntParams.UseWeightedAverages));
break;
case ViscosityMode.Viscoelastic:
//comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_Standard(LsTrk, 1 / reynoldsA, 1 / reynoldsB, penalty * 1.0, d, false));
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_FullySymmetric(LsTrk, betaA / reynoldsA, betaB / reynoldsB, penalty, d, dntParams.UseWeightedAverages));
comps.Add(new Operator.Viscosity.StressDivergenceAtLevelSet(LsTrk, reynoldsA, reynoldsB, penalty1, penalty2, d, dntParams.UseWeightedAverages));
break;
default:
throw new NotImplementedException();
}
}
}