public void Equals_qualified_names_equals_equatable()
{
DomName n = DomName.Create(DomNamespace.Default, "default");
Assert.False(n.Equals(null));
Assert.True(n.Equals(n));
}
public void WithLocalName_should_change_nominal()
{
DomName n = DomName.Create(DomNamespace.Default, "default");
n = n.WithLocalName("name");
Assert.Same("name", n.LocalName);
}
public void Parse_should_parse_expanded_names()
{
DomName qn = DomName.Parse("{http://ns.example.com/mushroom-kingdom} Mario");
Assert.Equal("Mario", qn.LocalName);
Assert.Equal("http://ns.example.com/mushroom-kingdom", qn.NamespaceUri);
}
public void WithNamespace_should_change_nominal()
{
DomName n = DomName.Create(DomNamespace.Default, "default");
DomNamespace nu = DomNamespace.Create("https://example.com");
n = n.WithNamespace(nu);
Assert.Same(nu, n.Namespace);
}
public void Action_will_not_throw_on_context_that_allows_it(Action <DomName> action)
{
action = RebindDelegate(action);
// This name is invalid in XML but valid in HTML
var invalidXmlName = DomName.Create(DomNamespace.Default, "t=s");
Document.NameContext = DomNameContext.Html;
Given(invalidXmlName).Expect(action).Not.ToThrow.Exception();
}
public void Create_should_generate_xml_semantics()
{
var dom = DomName.Create("xmlns:a");
Assert.Equal("xmlns:a", dom.LocalName);
Assert.Null(dom.Prefix);
Assert.Empty(dom.NamespaceUri);
Assert.Equal("xmlns", dom.TryXmlSemantics().Value.Prefix);
Assert.Equal("a", dom.TryXmlSemantics().Value.LocalName);
}
public void Document_OuterXml_should_treat_prefixed_name_as_is()
{
var doc = new DomDocument();
doc.AppendElement(DomName.Create("prefix:name"));
// In the default DomNameContext, the prefix is treated as part of the
// local name, and thus prints out as-is
Assert.Equal("<prefix:name/>", doc.OuterXml);
}
public void Add_will_detect_duplicates_on_map_key_equality()
{
var list = new List <DomAttribute>();
var subject = new DomAttributeCollectionImpl(list, DomNameComparer.IgnoreCase);
subject.Add(new DomAttribute(DomName.Create("a")));
var ex = Record.Exception(() => subject.Add(new DomAttribute(DomName.Create("A"))));
Assert.Contains("already exists", ex.Message);
}
public void Action_will_throw_on_invalid_name(Action <DomName> action)
{
action = RebindDelegate(action);
// This name is invalid in XML but valid in HTML
var invalidXmlName = DomName.Create(DomNamespace.Default, "t=s");
Given(invalidXmlName).Expect(action).ToThrow.Exception <ArgumentException>();
Given(invalidXmlName).Expect(action).ToThrow.Message.StartsWith(
"Name `t=s' cannot be used in this context"
);
}
public void NodeFactory_for_default_document_creates_HTML_elements()
{
var nodeFactory = HtmlProviderFactory.Instance.CreateDocument().NodeFactory;
Assert.Equal(
typeof(HtmlElement),
nodeFactory.GetElementNodeType(DomName.Create("x"))
);
Assert.IsInstanceOf <HtmlElement>(
nodeFactory.CreateElement(DomName.Create("x"))
);
}
public void Equals_operator_should_apply()
{
DomName n = DomName.Create(DomNamespace.Default, "default");
DomName m = n;
Assert.False(n == null);
Assert.True(n != null);
Assert.False(null == n);
Assert.True(null != n);
Assert.True(m == n);
Assert.False(m != n);
}
public void Document_OuterXml_should_not_print_prefixed_name_prefix_in_XML_name_context()
{
var doc = new DomDocument {
NameContext = DomNameContext.Xml,
};
doc.AppendElement(DomName.Create("prefix:name"));
// The prefix was used but not bound to a namespace, hence it
// is not printed out in XML, and there are no XMLNS attributes.
// TODO It is possible that XMLNS might not even get added until _at least_ one
// binding is present
Assert.Equal("<name xmlns=\"http://www.w3.org/2000/xmlns/\"/>", doc.OuterXml);
}
private void ByTag()
{
string tagName = tq.ConsumeElementSelector();
if (tagName.Length == 0)
{
throw Failure.EmptyString("tagName");
}
// namespaces: if element name is "abc:def", selector must be "abc|def", so flip:
if (tagName.Contains("|"))
{
tagName = tagName.Replace("|", ":");
}
evals.Add(new Evaluator.Tag(DomName.Create(tagName.Trim().ToLower())));
}
public override bool ValidateData()
{
DomName d = DomName.Root;
string x;
string y = "";
var rdr = new System.IO.StringReader(txtTo.Text.Trim());
while (true)
{
x = rdr.ReadLine();
if (x == null)
{
break;
}
if (x.Length == 0)
{
continue;
}
x = x.Replace(" ", "");
if (!DomName.TryParse(x, ref d))
{
ShowErr("Invalid domain name in 'Alias zone names': " + x);
return(false);
}
y += x + "\r\n";
}
rdr.Close();
txtTo.Text = y;
if (y.Length == 0)
{
ShowErr("At least one Alias Zone Name must be specified");
return(false);
}
txtFrom.Text = txtFrom.Text.Trim().ToLowerInvariant();
if (!DomName.TryParse(txtFrom.Text, ref d))
{
ShowErr("Invalid 'Clone from zone' domain name");
return(false);
}
return(true);
}
public void Parse_should_parse_default_ns()
{
DomName qn = DomName.Parse("Mario");
Assert.Equal("Mario", qn.LocalName);
}
public void TryParse_should_detect_non_registered_prefixes()
{
DomName qn;
Assert.False(DomName.TryParse("nonexistant:a", out qn));
}
public void ToString_should_format_prefix_binding()
{
DomName qn = DomName.Parse("{http://ns.example.com/mushroom-kingdom} Mario").WithPrefix("mk");
Assert.Equal("mk:Mario", qn.ToString("P"));
}
public Tag(DomName tagName)
{
_tagName = tagName;
}
public Type GetElementNodeType(DomName name)
{
return(typeof(HtmlElement));
}
public override void WriteStartAttribute(DomName name)
{
}
/// <summary>
/// ctor for the operator factory, where the equation compnents are set
/// </summary>
/// <param name="config"></param>
/// <param name="_LsTrk"></param>
/// <param name="_HMFdegree"></param>
/// <param name="BcMap"></param>
/// <param name="degU"></param>
public XNSE_OperatorFactory(IXNSE_Configuration config, LevelSetTracker _LsTrk, int _HMFdegree, IncompressibleMultiphaseBoundaryCondMap BcMap, int degU)
{
this.LsTrk = _LsTrk;
this.D = _LsTrk.GridDat.SpatialDimension;
this.HMFDegree = _HMFdegree;
this.physParams = config.getPhysParams;
this.dntParams = config.getDntParams;
// test input
// ==========
{
if (config.getDomBlocks.GetLength(0) != 2 || config.getCodBlocks.GetLength(0) != 2)
{
throw new ArgumentException();
}
if ((config.getPhysParams.mu_A <= 0) && (config.getPhysParams.mu_B <= 0))
{
config.isViscous = false;
}
else
{
if ((config.getPhysParams.mu_A <= 0) || (config.getPhysParams.mu_B <= 0))
{
throw new ArgumentException();
}
}
if ((config.getPhysParams.rho_A <= 0) || (config.getPhysParams.rho_B <= 0))
{
throw new ArgumentException();
}
if (_LsTrk.SpeciesNames.Count != 2)
{
throw new ArgumentException();
}
if (!(_LsTrk.SpeciesNames.Contains("A") && _LsTrk.SpeciesNames.Contains("B")))
{
throw new ArgumentException();
}
}
// full operator:
// ==============
CodName = ArrayTools.Cat(EquationNames.MomentumEquations(D), EquationNames.ContinuityEquation);
Params = ArrayTools.Cat(
VariableNames.Velocity0Vector(D),
VariableNames.Velocity0MeanVector(D),
VariableNames.NormalVector(D),
VariableNames.Curvature,
VariableNames.SurfaceForceVector(D)
);
DomName = ArrayTools.Cat(VariableNames.VelocityVector(D), VariableNames.Pressure);
// selected part:
if (config.getCodBlocks[0])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(0, D));
}
if (config.getCodBlocks[1])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(D, 1));
}
if (config.getDomBlocks[0])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(0, D));
}
if (config.getDomBlocks[1])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(D, 1));
}
// create Operator
// ===============
m_XOp = new XSpatialOperatorMk2(DomNameSelected, Params, CodNameSelected, (A, B, C) => _HMFdegree, this.LsTrk.SpeciesIdS.ToArray());
// add components
// ==============
// species bulk components
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
// Navier Stokes equations
XOperatorComponentsFactory.AddSpeciesNSE(m_XOp, config, D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], BcMap, LsTrk, out U0meanrequired);
// continuity equation
if (config.isContinuity)
{
XOperatorComponentsFactory.AddSpeciesContinuityEq(m_XOp, config, D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], BcMap);
}
}
// interface components
XOperatorComponentsFactory.AddInterfaceNSE(m_XOp, config, D, BcMap, LsTrk); // surface stress tensor
XOperatorComponentsFactory.AddSurfaceTensionForce(m_XOp, config, D, BcMap, LsTrk, degU, out NormalsRequired, out CurvatureRequired); // surface tension force
if (config.isContinuity)
{
XOperatorComponentsFactory.AddInterfaceContinuityEq(m_XOp, config, D, LsTrk); // continuity equation
}
m_XOp.Commit();
}
public HtmlAttributeDefinition(DomName name) : base(name)
{
}
public HtmlAttributeDefinition(string name) : base(DomName.Create(name))
{
}
public void Parse_should_throw_oninvalid_names()
{
Assert.Throws <ArgumentException>(() => { DomName.Parse("*&Ma^^rio"); });
Assert.Throws <ArgumentException>(() => { DomName.Parse("name whitespace"); });
Assert.Throws <ArgumentException>(() => { DomName.Parse(""); });
}
public void Create_local_name_is_required()
{
Assert.Throws <ArgumentException>(() => { DomName.Create(DomNamespace.Default, ""); });
Assert.Throws <ArgumentNullException>(() => { DomName.Create(DomNamespace.Default, null); });
}
public void ToString_should_format(string expected, string format)
{
DomName qn = DomName.Parse("{http://ns.example.com/mushroom-kingdom} Mario");
Assert.Equal(expected, qn.ToString(format));
}
public Type GetAttributeNodeType(DomName name)
{
return(typeof(HtmlAttribute));
}
public void ToString_should_format_default()
{
DomName qn = DomName.Parse("{http://ns.example.com/mushroom-kingdom} Mario");
Assert.Equal("{http://ns.example.com/mushroom-kingdom} Mario", qn.ToString());
}
public OperatorFactoryMk2(
OperatorConfigurationMk2 config,
LevelSetTracker _LsTrk,
int _HMFdegree,
int degU,
IncompressibleMultiphaseBoundaryCondMap BcMap,
bool _movingmesh,
bool _evaporation)
{
// variable names
// ==============
D = _LsTrk.GridDat.SpatialDimension;
this.LsTrk = _LsTrk;
this.HMFDegree = _HMFdegree;
this.dntParams = config.dntParams.CloneAs();
this.physParams = config.physParams.CloneAs();
this.UseExtendedVelocity = config.UseXDG4Velocity;
this.movingmesh = _movingmesh;
this.evaporation = _evaporation;
// test input
// ==========
{
if (config.DomBlocks.GetLength(0) != 2 || config.CodBlocks.GetLength(0) != 2)
{
throw new ArgumentException();
}
if (config.physParams.mu_A == 0.0 && config.physParams.mu_B == 0.0)
{
muIs0 = true;
}
else
{
if (config.physParams.mu_A <= 0)
{
throw new ArgumentException();
}
if (config.physParams.mu_B <= 0)
{
throw new ArgumentException();
}
}
if (config.physParams.rho_A <= 0)
{
throw new ArgumentException();
}
if (config.physParams.rho_B <= 0)
{
throw new ArgumentException();
}
if (_LsTrk.SpeciesNames.Count != 2)
{
throw new ArgumentException();
}
if (!(_LsTrk.SpeciesNames.Contains("A") && _LsTrk.SpeciesNames.Contains("B")))
{
throw new ArgumentException();
}
}
// full operator:
CodName = ((new string[] { "momX", "momY", "momZ" }).GetSubVector(0, D)).Cat("div");
Params = ArrayTools.Cat(
VariableNames.Velocity0Vector(D),
VariableNames.Velocity0MeanVector(D),
"Curvature",
(new string[] { "surfForceX", "surfForceY", "surfForceZ" }).GetSubVector(0, D),
(new string[] { "NX", "NY", "NZ" }).GetSubVector(0, D),
(new string[] { "GradTempX", "GradTempY", "GradTempZ" }.GetSubVector(0, D)),
VariableNames.Temperature,
"DisjoiningPressure");
DomName = ArrayTools.Cat(VariableNames.VelocityVector(D), VariableNames.Pressure);
// selected part:
if (config.CodBlocks[0])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(0, D));
}
if (config.CodBlocks[1])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(D, 1));
}
if (config.DomBlocks[0])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(0, D));
}
if (config.DomBlocks[1])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(D, 1));
}
muA = config.physParams.mu_A;
muB = config.physParams.mu_B;
rhoA = config.physParams.rho_A;
rhoB = config.physParams.rho_B;
sigma = config.physParams.Sigma;
MatInt = !evaporation;
double kA = config.thermParams.k_A;
double kB = config.thermParams.k_B;
double hVapA = config.thermParams.hVap_A;
double hVapB = config.thermParams.hVap_B;
double Tsat = config.thermParams.T_sat;
double R_int = 0.0;
//double T_intMin = 0.0;
if (evaporation)
{
double f = config.thermParams.fc;
double R = config.thermParams.Rc;
//double pc = config.thermParams.pc;
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())));
}
this.CurvatureRequired = true;
}
double p_c = config.thermParams.pc;
// create Operator
// ===============
m_OP = new XSpatialOperatorMk2(DomNameSelected, Params, CodNameSelected, (A, B, C) => _HMFdegree, this.LsTrk.SpeciesIdS.ToArray());
// build the operator
// ==================
{
// Momentum equation
// =================
if (config.physParams.IncludeConvection && config.Transport)
{
for (int d = 0; d < D; d++)
{
var comps = m_OP.EquationComponents[CodName[d]];
double LFFA = config.dntParams.LFFA;
double LFFB = config.dntParams.LFFB;
//var conv = new Operator.Convection.ConvectionInBulk_LLF(D, BcMap, d, rhoA, rhoB, LFFA, LFFB, LsTrk);
//comps.Add(conv); // Bulk component
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
double rhoSpc = 0.0;
double LFFSpc = 0.0;
switch (LsTrk.SpeciesNames[spc])
{
case "A": rhoSpc = rhoA; LFFSpc = LFFA; break;
case "B": rhoSpc = rhoB; LFFSpc = LFFB; break;
default: throw new ArgumentException("Unknown species.");
}
var conv = new Operator.Convection.ConvectionInSpeciesBulk_LLF(D, BcMap, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], d, rhoSpc, LFFSpc, LsTrk);
comps.Add(conv); // Bulk component
}
comps.Add(new Operator.Convection.ConvectionAtLevelSet_LLF(d, D, LsTrk, rhoA, rhoB, LFFA, LFFB, config.physParams.Material, BcMap, movingmesh)); // LevelSet component
if (evaporation)
{
comps.Add(new Operator.Convection.GeneralizedConvectionAtLevelSet_DissipativePart(d, D, LsTrk, rhoA, rhoB, LFFA, LFFB, BcMap, kA, kB, hVapA, hVapB, R_int, Tsat, sigma, p_c));
}
}
this.U0meanrequired = true;
}
// pressure gradient
// =================
if (config.PressureGradient)
{
for (int d = 0; d < D; d++)
{
var comps = m_OP.EquationComponents[CodName[d]];
//var pres = new Operator.Pressure.PressureInBulk(d, BcMap);
//comps.Add(pres);
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
var pres = new Operator.Pressure.PressureInSpeciesBulk(d, BcMap, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc]);
comps.Add(pres);
}
var presLs = new Operator.Pressure.PressureFormAtLevelSet(d, D, LsTrk); //, dntParams.UseWeightedAverages, muA, muB);
comps.Add(presLs);
}
}
// viscous operator
// ================
if (config.Viscous && !muIs0)
{
for (int d = 0; d < D; d++)
{
var comps = m_OP.EquationComponents[CodName[d]];
double penalty = dntParams.PenaltySafety;
switch (dntParams.ViscosityMode)
{
case ViscosityMode.Standard: {
// Bulk operator:
var Visc = new Operator.Viscosity.ViscosityInBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, d, D, muA, muB); // , _betaA: this.physParams.betaS_A, _betaB: this.physParams.betaS_B);
comps.Add(Visc);
if (dntParams.UseGhostPenalties)
{
var ViscPenalty = new Operator.Viscosity.ViscosityInBulk_GradUTerm(penalty * 1.0, 0.0, BcMap, d, D, muA, muB);
m_OP.GhostEdgesOperator.EquationComponents[CodName[d]].Add(ViscPenalty);
}
// Level-Set operator:
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_Standard(LsTrk, muA, muB, penalty * 1.0, d, true));
break;
}
case ViscosityMode.TransposeTermMissing: {
// Bulk operator:
var Visc = new Operator.Viscosity.ViscosityInBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, d, D, muA, muB);
comps.Add(Visc);
if (dntParams.UseGhostPenalties)
{
var ViscPenalty = new Operator.Viscosity.ViscosityInBulk_GradUTerm(penalty * 1.0, 0.0, BcMap, d, D, muA, muB);
m_OP.GhostEdgesOperator.EquationComponents[CodName[d]].Add(ViscPenalty);
}
// Level-Set operator:
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_Standard(LsTrk, muA, muB, penalty * 1.0, d, false));
break;
}
case ViscosityMode.FullySymmetric: {
// Bulk operator
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
var Visc1 = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], d, D, muA, muB);
comps.Add(Visc1);
var Visc2 = new Operator.Viscosity.ViscosityInSpeciesBulk_GradUtranspTerm(
dntParams.UseGhostPenalties ? 0.0 : penalty, 1.0,
BcMap, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], d, D, muA, muB);
comps.Add(Visc2);
}
if (dntParams.UseGhostPenalties)
{
var Visc1Penalty = new Operator.Viscosity.ViscosityInBulk_GradUTerm(
penalty, 0.0,
BcMap, d, D, muA, muB);
var Visc2Penalty = new Operator.Viscosity.ViscosityInBulk_GradUtranspTerm(
penalty, 0.0,
BcMap, d, D, muA, muB);
m_OP.GhostEdgesOperator.EquationComponents[CodName[d]].Add(Visc1Penalty);
m_OP.GhostEdgesOperator.EquationComponents[CodName[d]].Add(Visc2Penalty);
}
// Level-Set operator
comps.Add(new Operator.Viscosity.ViscosityAtLevelSet_FullySymmetric(LsTrk, muA, muB, penalty, d, dntParams.UseWeightedAverages));
if (this.evaporation)
{
comps.Add(new Operator.Viscosity.GeneralizedViscosityAtLevelSet_FullySymmetric(LsTrk, muA, muB, penalty, d, rhoA, rhoB, kA, kB, hVapA, R_int, Tsat, sigma, p_c));
}
break;
}
default:
throw new NotImplementedException();
}
}
}
// Continuum equation
// ==================
if (config.continuity)
{
for (int d = 0; d < D; d++)
{
//var src = new Operator.Continuity.DivergenceInBulk_Volume(d, D, rhoA, rhoB, config.dntParams.ContiSign, config.dntParams.RescaleConti);
//var flx = new Operator.Continuity.DivergenceInBulk_Edge(d, BcMap, rhoA, rhoB, config.dntParams.ContiSign, config.dntParams.RescaleConti);
//m_OP.EquationComponents["div"].Add(flx);
//m_OP.EquationComponents["div"].Add(src);
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
double rhoSpc = 0.0;
switch (LsTrk.SpeciesNames[spc])
{
case "A": rhoSpc = rhoA; break;
case "B": rhoSpc = rhoB; break;
default: throw new ArgumentException("Unknown species.");
}
var src = new Operator.Continuity.DivergenceInSpeciesBulk_Volume(d, D, LsTrk.SpeciesIdS[spc], rhoSpc, config.dntParams.ContiSign, config.dntParams.RescaleConti);
var flx = new Operator.Continuity.DivergenceInSpeciesBulk_Edge(d, BcMap, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], rhoSpc, config.dntParams.ContiSign, config.dntParams.RescaleConti);
m_OP.EquationComponents["div"].Add(flx);
m_OP.EquationComponents["div"].Add(src);
}
}
var divPen = new Operator.Continuity.DivergenceAtLevelSet(D, LsTrk, rhoA, rhoB, MatInt, config.dntParams.ContiSign, config.dntParams.RescaleConti); //, dntParams.UseWeightedAverages, muA, muB);
m_OP.EquationComponents["div"].Add(divPen);
if (evaporation)
{
var divPenGen = new Operator.Continuity.GeneralizedDivergenceAtLevelSet(D, LsTrk, rhoA, rhoB, config.dntParams.ContiSign, config.dntParams.RescaleConti, kA, kB, hVapA, R_int, Tsat, sigma, p_c);
m_OP.EquationComponents["div"].Add(divPenGen);
}
}
// surface tension
// ===============
if (config.PressureGradient && config.physParams.Sigma != 0.0)
{
// isotropic part of the surface stress tensor
if (config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Flux ||
config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Local ||
config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_ContactLine)
{
for (int d = 0; d < D; d++)
{
if (config.dntParams.SST_isotropicMode != SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_ContactLine)
{
IEquationComponent G = new SurfaceTension_LaplaceBeltrami_Surface(d, config.physParams.Sigma * 0.5);
IEquationComponent H = new SurfaceTension_LaplaceBeltrami_BndLine(d, config.physParams.Sigma * 0.5, config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.LaplaceBeltrami_Flux);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(G);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(H);
}
else
{
IEquationComponent isoSurfT = new IsotropicSurfaceTension_LaplaceBeltrami(d, D, config.physParams.Sigma * 0.5, BcMap.EdgeTag2Type, config.physParams.theta_e, config.physParams.betaL);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(isoSurfT);
}
}
this.NormalsRequired = true;
}
else if (config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_Projected ||
config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_ClosestPoint ||
config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_LaplaceBeltramiMean ||
config.dntParams.SST_isotropicMode == SurfaceStressTensor_IsotropicMode.Curvature_Fourier)
{
for (int d = 0; d < D; d++)
{
m_OP.EquationComponents[CodName[d]].Add(new CurvatureBasedSurfaceTension(d, D, LsTrk, config.physParams.Sigma));
}
this.CurvatureRequired = true;
}
else
{
throw new NotImplementedException("Not implemented.");
}
// dynamic part
if (config.dntParams.SurfStressTensor != SurfaceSressTensor.Isotropic)
{
double muI = config.physParams.mu_I;
double lamI = config.physParams.lambda_I;
double penalty_base = (degU + 1) * (degU + D) / D;
double penalty = penalty_base * dntParams.PenaltySafety;
// surface shear viscosity
if (config.dntParams.SurfStressTensor == SurfaceSressTensor.SurfaceRateOfDeformation ||
config.dntParams.SurfStressTensor == SurfaceSressTensor.SemiImplicit ||
config.dntParams.SurfStressTensor == SurfaceSressTensor.FullBoussinesqScriven)
{
for (int d = 0; d < D; d++)
{
var surfDeformRate = new BoussinesqScriven_SurfaceDeformationRate_GradU(d, muI * 0.5, penalty);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(surfDeformRate);
if (config.dntParams.SurfStressTensor != SurfaceSressTensor.SemiImplicit)
{
var surfDeformRateT = new BoussinesqScriven_SurfaceDeformationRate_GradUTranspose(d, muI * 0.5, penalty);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(surfDeformRateT);
}
}
}
// surface dilatational viscosity
if (config.dntParams.SurfStressTensor == SurfaceSressTensor.SurfaceVelocityDivergence ||
config.dntParams.SurfStressTensor == SurfaceSressTensor.FullBoussinesqScriven)
{
for (int d = 0; d < D; d++)
{
var surfVelocDiv = new BoussinesqScriven_SurfaceVelocityDivergence(d, muI * 0.5, lamI * 0.5, penalty, BcMap.EdgeTag2Type);
m_OP.SurfaceElementOperator.EquationComponents[CodName[d]].Add(surfVelocDiv);
}
}
}
// stabilization
if (config.dntParams.UseLevelSetStabilization)
{
for (int d = 0; d < D; d++)
{
m_OP.EquationComponents[CodName[d]].Add(new LevelSetStabilization(d, D, LsTrk));
}
}
}
// surface force term
// ==================
if (config.PressureGradient && config.physParams.useArtificialSurfaceForce)
{
for (int d = 0; d < D; d++)
{
m_OP.EquationComponents[CodName[d]].Add(new SurfaceTension_ArfForceSrc(d, D, LsTrk));
}
}
// evaporation (mass flux)
// =======================
if (evaporation)
{
for (int d = 0; d < D; d++)
{
m_OP.EquationComponents[CodName[d]].Add(new Operator.DynamicInterfaceConditions.MassFluxAtInterface(d, D, LsTrk, rhoA, rhoB, kA, kB, hVapA, R_int, Tsat, sigma, p_c));
}
}
}
// Finalize
// ========
m_OP.Commit();
}
/// <summary>
/// ctor for the operator factory, where the equation compnents are set
/// </summary>
/// <param name="_config"></param>
/// <param name="_LsTrk"></param>
/// <param name="_HMFdegree"></param>
/// <param name="BcMap"></param>
/// <param name="thermBcMap"></param>
/// <param name="degU"></param>
public XNSFE_OperatorFactory(XNSFE_OperatorConfiguration _config, LevelSetTracker _LsTrk, int _HMFdegree,
IncompressibleMultiphaseBoundaryCondMap BcMap, ThermalMultiphaseBoundaryCondMap thermBcMap, int degU, IDictionary <SpeciesId, IEnumerable <double> > MassScale)
{
this.config = _config;
this.LsTrk = _LsTrk;
this.D = _LsTrk.GridDat.SpatialDimension;
this.HMFDegree = _HMFdegree;
this.physParams = config.getPhysParams;
this.thermParams = config.getThermParams;
this.dntParams = config.getDntParams;
// test input
// ==========
{
if ((config.getPhysParams.mu_A <= 0) && (config.getPhysParams.mu_B <= 0))
{
config.isViscous = false;
}
else
{
if ((config.getPhysParams.mu_A <= 0) || (config.getPhysParams.mu_B <= 0))
{
throw new ArgumentException();
}
}
if ((config.getPhysParams.rho_A <= 0) || (config.getPhysParams.rho_B <= 0))
{
throw new ArgumentException();
}
if (_LsTrk.SpeciesNames.Count != 2)
{
throw new ArgumentException();
}
if (!(_LsTrk.SpeciesNames.Contains("A") && _LsTrk.SpeciesNames.Contains("B")))
{
throw new ArgumentException();
}
}
// full operator:
// ==============
CodName = ArrayTools.Cat(EquationNames.MomentumEquations(D), EquationNames.ContinuityEquation);
Params = ArrayTools.Cat(
VariableNames.Velocity0Vector(D),
VariableNames.Velocity0MeanVector(D),
VariableNames.NormalVector(D),
VariableNames.Curvature,
VariableNames.SurfaceForceVector(D)
);
DomName = ArrayTools.Cat(VariableNames.VelocityVector(D), VariableNames.Pressure);
if (config.solveEnergy)
{
CodName = ArrayTools.Cat(CodName, EquationNames.KineticEnergyEquation);
Params = ArrayTools.Cat(Params,
VariableNames.VelocityX_GradientVector(),
VariableNames.VelocityY_GradientVector(),
new string[] { "VelocityXGradX_GradientX", "VelocityXGradX_GradientY" },
new string[] { "VelocityXGradY_GradientX", "VelocityXGradY_GradientY" },
new string[] { "VelocityYGradX_GradientX", "VelocityYGradX_GradientY" },
new string[] { "VelocityYGradY_GradientX", "VelocityYGradY_GradientY" },
VariableNames.Pressure0,
VariableNames.PressureGradient(D),
VariableNames.GravityVector(D)
);
DomName = ArrayTools.Cat(DomName, VariableNames.KineticEnergy);
}
if (config.solveHeat)
{
Params = ArrayTools.Cat(Params,
VariableNames.Temperature0,
VariableNames.HeatFlux0Vector(D),
VariableNames.DisjoiningPressure
);
if (config.conductMode == ConductivityInSpeciesBulk.ConductivityMode.SIP)
{
CodName = ArrayTools.Cat(CodName, EquationNames.HeatEquation);
DomName = ArrayTools.Cat(DomName, VariableNames.Temperature);
}
else
{
CodName = ArrayTools.Cat(CodName, EquationNames.HeatEquation, EquationNames.AuxHeatFlux(D));
DomName = ArrayTools.Cat(DomName, VariableNames.Temperature, VariableNames.HeatFluxVector(D));
}
}
storedParams = new DGField[Params.Length];
// selected part:
if (config.getCodBlocks[0])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(0, D));
}
if (config.getCodBlocks[1])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(D, 1));
}
if (config.getDomBlocks[0])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(0, D));
}
if (config.getDomBlocks[1])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(D, 1));
}
int nBlocks = 2;
if (config.solveEnergy)
{
nBlocks = 3;
if (config.getCodBlocks[2])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(D + 1, 1));
}
if (config.getDomBlocks[2])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(D + 1, 1));
}
}
if (config.solveHeat)
{
if (config.getCodBlocks[nBlocks])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(nBlocks + (D - 1) + 1, 1));
}
if (config.getDomBlocks[nBlocks])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(nBlocks + (D - 1) + 1, 1));
}
if (config.conductMode != ConductivityInSpeciesBulk.ConductivityMode.SIP)
{
if (config.getCodBlocks[nBlocks + 1])
{
CodNameSelected = ArrayTools.Cat(CodNameSelected, CodName.GetSubVector(nBlocks + (D - 1) + 2, D));
}
if (config.getDomBlocks[nBlocks + 1])
{
DomNameSelected = ArrayTools.Cat(DomNameSelected, DomName.GetSubVector(nBlocks + (D - 1) + 2, D));
}
}
}
// create Operator
// ===============
m_XOp = new XSpatialOperatorMk2(DomNameSelected, Params, CodNameSelected, (A, B, C) => _HMFdegree, this.LsTrk.SpeciesNames);
// add Navier-Stokes components
// ============================
// species bulk components
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
// Navier Stokes equations
Solution.XNSECommon.XOperatorComponentsFactory.AddSpeciesNSE(m_XOp, config, D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], BcMap, LsTrk, out U0meanrequired);
// continuity equation
if (config.isContinuity)
{
Solution.XNSECommon.XOperatorComponentsFactory.AddSpeciesContinuityEq(m_XOp, config, D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], BcMap);
}
}
// interface components
Solution.XNSECommon.XOperatorComponentsFactory.AddInterfaceNSE(m_XOp, config, D, BcMap, LsTrk); // surface stress tensor
Solution.XNSECommon.XOperatorComponentsFactory.AddSurfaceTensionForce(m_XOp, config, D, BcMap, LsTrk, degU, out NormalsRequired, out CurvatureRequired); // surface tension force
if (config.isContinuity)
{
Solution.XNSECommon.XOperatorComponentsFactory.AddInterfaceContinuityEq(m_XOp, config, D, LsTrk); // continuity equation
}
// add kinetic energy equation components
// ======================================
if (config.solveEnergy)
{
// species bulk components
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
Solution.EnergyCommon.XOperatorComponentsFactory.AddSpeciesKineticEnergyEquation(m_XOp, config, D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], BcMap, LsTrk);
}
// interface components
Solution.EnergyCommon.XOperatorComponentsFactory.AddInterfaceKineticEnergyEquation(m_XOp, config, D, BcMap, LsTrk, degU);
CurvatureRequired = true;
}
// add Heat equation components
// ============================
if (config.solveHeat)
{
// species bulk components
for (int spc = 0; spc < LsTrk.TotalNoOfSpecies; spc++)
{
Solution.XheatCommon.XOperatorComponentsFactory.AddSpeciesHeatEq(m_XOp, config,
D, LsTrk.SpeciesNames[spc], LsTrk.SpeciesIdS[spc], thermBcMap, LsTrk);
}
// interface components
Solution.XheatCommon.XOperatorComponentsFactory.AddInterfaceHeatEq(m_XOp, config, D, thermBcMap, LsTrk);
}
// add Evaporation interface components
// ====================================
if (config.isEvaporation)
{
XOperatorComponentsFactory.AddInterfaceNSE_withEvaporation(m_XOp, config, D, LsTrk);
if (config.isContinuity)
{
XOperatorComponentsFactory.AddInterfaceContinuityEq_withEvaporation(m_XOp, config, D, LsTrk);
}
}
// create temporal operator
// ========================
var TempOp = new ConstantXTemporalOperator(m_XOp, 0.0);
m_XOp.TemporalOperator = TempOp;
foreach (var kv in MassScale)
{
TempOp.DiagonalScale[LsTrk.GetSpeciesName(kv.Key)].SetV(kv.Value.ToArray());
}
// Finalize
// ========
m_XOp.Commit();
}
