/// <summary>
/// Ctor for variable density flows
/// </summary>
/// <param name="EoS">The material law</param>
/// <param name="energy">Set conti: true for the energy equation</param>
/// <param name="ArgumentOrdering"></param>
/// <param name="TimeStepSize"></param>
public MassMatrixComponent(MaterialLaw EoS, String[] ArgumentOrdering, int j, PhysicsMode _physicsMode, int spatDim, int NumberOfReactants)
{
this.j = j;
this.EoS = EoS;
m_ParameterOrdering = EoS.ParameterOrdering;
this.m_SpatialDimension = spatDim;
this.NumberOfReactants = NumberOfReactants;
int SpatDim = 2;
int numberOfReactants = 3;
this.physicsMode = _physicsMode;
switch (_physicsMode)
{
case PhysicsMode.Multiphase:
m_ArgumentOrdering = new string[] { VariableNames.LevelSet };
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim));
break;
case PhysicsMode.LowMach:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.Temperature);
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
case PhysicsMode.MixtureFraction:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.MixtureFraction);
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
case PhysicsMode.Combustion:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.Temperature, VariableNames.MassFractions(numberOfReactants - 1)); // u,v,w,T, Y0,Y1,Y2,Y3 as variables (Y4 is calculated as Y4 = 1- (Y0+Y1+Y2+Y3)
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor for low Mach number flows.
/// </summary>
/// <param name="Component"></param>
/// <param name="Bcmap"></param>
/// <param name="EoS"></param>
public Divergence_CentralDifferenceJacobian(int Component, IncompressibleBoundaryCondMap Bcmap, int SpatDim, MaterialLaw EoS, int NumberOfSpecies = -1)
: this(Component, Bcmap, SpatDim)
{
this.EoS = EoS;
switch (Bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
case PhysicsMode.Multiphase:
throw new ApplicationException("Wrong constructor");
case PhysicsMode.MixtureFraction:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), new string[] { VariableNames.MixtureFraction });
m_ParameterOrdering = null;
this.NumberOfSpecies = NumberOfSpecies;
break;
case PhysicsMode.LowMach:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), new string[] { VariableNames.Temperature });
break;
case PhysicsMode.Combustion:
if (NumberOfSpecies == -1)
{
throw new ArgumentException("NumberOfSpecies must be specified for combustion flows.");
}
string[] Parameters = ArrayTools.Cat(new string[] { VariableNames.Temperature }, VariableNames.MassFractions(NumberOfSpecies - 1));
this.NumberOfSpecies = NumberOfSpecies;
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), Parameters);
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor for incompressible flows.
/// </summary>
/// <param name="Component"></param>
/// <param name="Bcmap"></param>
public Divergence_CentralDifferenceJacobian(int Component, IncompressibleBoundaryCondMap Bcmap, int SpatDim)
{
this.Component = Component;
this.Bcmap = Bcmap;
this.VelFunction = Bcmap.bndFunction[VariableNames.Velocity_d(Component)];
m_SpatialDimension = SpatDim;
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim));
}
/// <summary>
/// Ctor for incompressible flows.
/// </summary>
/// <param name="SpatDim">
/// Spatial dimension (either 2 or 3).
/// </param>
/// <param name="_bcmap"></param>
/// <param name="_component"></param>
/// <param name="UseBoundaryVelocityParameter">
/// True, if (an offset to) the boundary velocity is supplied in form of parameter variables.
/// </param>
public LinearizedConvection(int SpatDim, IncompressibleBoundaryCondMap _bcmap, int _component, bool UseBoundaryVelocityParameter = false)
: this(SpatDim, _bcmap, _component)
{
m_UseBoundaryVelocityParameter = UseBoundaryVelocityParameter;
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim));
if (m_UseBoundaryVelocityParameter)
{
m_ParameterOrdering = ArrayTools.Cat(m_ParameterOrdering, VariableNames.BoundaryVelocityVector(SpatDim));
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="SpatDim">Spatial dimension (either 2 or 3)</param>
/// <param name="BcMap"></param>
/// <param name="EoS">Null for multiphase. Has to be given for Low-Mach and combustion to calculate density.</param>
/// <param name="Argument">Variable name of the argument (e.g. "Temperature" or "MassFraction0")</param>
public LinearizedScalarConvection2(int SpatDim, int NumberOfReactants, IncompressibleBoundaryCondMap BcMap, MaterialLaw EoS, string Argument = null)
{
this.NumberOfReactants = NumberOfReactants;
m_SpatialDimension = SpatDim;
m_bcmap = BcMap;
switch (BcMap.PhysMode)
{
case PhysicsMode.Multiphase:
this.Argument = VariableNames.LevelSet;
m_ArgumentOrdering = new string[] { VariableNames.LevelSet };
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim));
break;
case PhysicsMode.LowMach:
this.Argument = VariableNames.Temperature;
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Temperature0, VariableNames.Temperature0Mean);
m_ArgumentOrdering = new string[] { VariableNames.Temperature };
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
case PhysicsMode.Combustion:
this.Argument = Argument;
m_ParameterOrdering = ArrayTools.Cat(
VariableNames.Velocity0Vector(SpatDim),
VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Temperature0,
VariableNames.MassFractions0(NumberOfReactants),
VariableNames.Temperature0Mean,
VariableNames.MassFractionsMean(NumberOfReactants));
m_ArgumentOrdering = new string[] { Argument };
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor for common part of incompressible and low Mach number flows.
/// </summary>
public UpwindMomentumConvection(int SpatDim, IncompressibleBoundaryCondMap _bcmap, int _component, double __rho)
{
m_SpatialDimension = SpatDim;
m_bcmap = _bcmap;
m_component = _component;
m_rho = __rho;
velFunction = new Func <double[], double, double> [m_bcmap.MaxEdgeTagNo, SpatDim];
for (int d = 0; d < SpatDim; d++)
{
velFunction.SetColumn(m_bcmap.bndFunction[VariableNames.Velocity_d(d)], d);
}
}
/// <summary>
/// ctor.
/// </summary>
/// <param name="_penaltyBase"></param>
/// <param name="iComp">
/// component index
/// </param>
/// <param name="D">
/// spatial dimension.
/// </param>
/// <param name="bcmap"></param>
/// <param name="_ViscosityMode">
/// see <see cref="ViscosityOption"/>
/// </param>
/// <param name="constantViscosityValue">
/// Constant value for viscosity.
/// Needs to be given for <see cref="ViscosityOption.ConstantViscosity"/>.
/// </param>
/// <param name="reynolds">
/// Reynolds number for dimensionless formulation.
/// Needs to be given for <see cref="ViscosityOption.ConstantViscosityDimensionless"/> and <see cref="ViscosityOption.VariableViscosityDimensionless"/>.
/// </param>
/// <param name="EoS">
/// Optional material law for calculating the viscosity
/// as a function of the level-set.
/// Only available for <see cref="ViscosityOption.VariableViscosity"/> and <see cref="ViscosityOption.VariableViscosityDimensionless"/>.
/// </param>
protected swipViscosityBase(
double _penaltyBase,
int iComp, int D, IncompressibleBoundaryCondMap bcmap,
ViscosityOption _ViscosityMode, double constantViscosityValue = double.NaN, double reynolds = double.NaN, MaterialLaw EoS = null)
{
//Func<double, int, int, MultidimensionalArray, double> ComputePenalty = null) {
this.m_penalty_base = _penaltyBase;
//this.m_ComputePenalty = ComputePenalty;
this.m_iComp = iComp;
this.m_D = D;
//this.cj = PenaltyLengthScales;
velFunction = D.ForLoop(d => bcmap.bndFunction[VariableNames.Velocity_d(d)]);
EdgeTag2Type = bcmap.EdgeTag2Type;
this.m_PhysicsMode = bcmap.PhysMode;
this.m_ViscosityMode = _ViscosityMode;
switch (_ViscosityMode)
{
case ViscosityOption.ConstantViscosity:
if (double.IsNaN(constantViscosityValue))
{
throw new ArgumentException("constantViscosityValue is missing!");
}
this.m_constantViscosityValue = constantViscosityValue;
break;
case ViscosityOption.ConstantViscosityDimensionless:
if (double.IsNaN(reynolds))
{
throw new ArgumentException("reynolds number is missing!");
}
this.m_reynolds = reynolds;
break;
case ViscosityOption.VariableViscosity:
this.m_EoS = EoS;
break;
case ViscosityOption.VariableViscosityDimensionless:
if (double.IsNaN(reynolds))
{
throw new ArgumentException("reynolds number is missing!");
}
this.m_reynolds = reynolds;
this.m_EoS = EoS;
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="SpatDimension"></param>
/// <param name="EoS"></param>
/// <param name="bcmap"></param>
public CoupledLaxFriedrichsScalar(int SpatDimension, MaterialLaw EoS, IncompressibleBoundaryCondMap bcmap)
{
this.SpatDimension = SpatDimension;
this.EoS = EoS;
this.bcmap = bcmap;
velFunction = new Func <double[], double, double> [GridCommons.FIRST_PERIODIC_BC_TAG, SpatDimension];
for (int d = 0; d < SpatDimension; d++)
{
velFunction.SetColumn(bcmap.bndFunction[VariableNames.Velocity_d(d)], d);
}
scalarFunction = bcmap.bndFunction[VariableNames.LevelSet];
}
/// <summary>
/// Ctor for common part of incompressible and low Mach number flows.
/// </summary>
/// <param name="SpatDim"></param>
/// <param name="_bcmap"></param>
/// <param name="_component"></param>
private LinearizedConvection(int SpatDim, IncompressibleBoundaryCondMap _bcmap, int _component)
{
m_SpatialDimension = SpatDim;
m_bcmap = _bcmap;
m_component = _component;
velFunction = new Func <double[], double, double> [GridCommons.FIRST_PERIODIC_BC_TAG, SpatDim];
for (int d = 0; d < SpatDim; d++)
{
velFunction.SetColumn(m_bcmap.bndFunction[VariableNames.Velocity_d(d)], d);
}
PhysMode = _bcmap.PhysMode;
}
/// <summary>
/// Ctor for variable density flows,
/// i.e. low Mach number flows and
/// multiphase flows with smooth interface.
/// </summary>
/// <param name="SpatDim">
/// Spatial dimension (either 2 or 3).
/// </param>
/// <param name="_bcmap"></param>
/// <param name="_component"></param>
/// <param name="EoS">
/// Material law for variable density flows.
/// </param>
public LinearizedConvection(int SpatDim, IncompressibleBoundaryCondMap _bcmap, int _component, MaterialLaw EoS, int NumberOfReactants = -1)
: this(SpatDim, _bcmap, _component)
{
//m_VariableDensity = true;
this.EoS = EoS;
this.NumberOfReactants = NumberOfReactants;
switch (_bcmap.PhysMode)
{
case PhysicsMode.LowMach:
scalarFunction = m_bcmap.bndFunction[VariableNames.Temperature];
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim),
VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Temperature0,
VariableNames.Temperature0Mean);
break;
case PhysicsMode.Multiphase:
scalarFunction = m_bcmap.bndFunction[VariableNames.LevelSet];
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim),
VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Phi0,
VariableNames.Phi0Mean);
break;
case PhysicsMode.Combustion:
if (NumberOfReactants == -1)
{
throw new ArgumentException("NumberOfReactants needs to be specified!");
}
m_ParameterOrdering = ArrayTools.Cat(
VariableNames.Velocity0Vector(SpatDim),
VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Temperature0,
VariableNames.MassFractions0(NumberOfReactants),
VariableNames.Temperature0Mean,
VariableNames.MassFractionsMean(NumberOfReactants));
break;
case PhysicsMode.Viscoelastic:
throw new ApplicationException("Using of wrong constructor for viscoelastic flows.");
case PhysicsMode.Incompressible:
throw new ApplicationException("Using of wrong constructor for incompressible flows.");
default:
throw new NotImplementedException();
}
}
static string[] BndFunctions(IGridData g, PhysicsMode _PhysicsMode)
{
int D = g.SpatialDimension;
string[] ScalarFields;
switch (_PhysicsMode)
{
case PhysicsMode.Incompressible:
ScalarFields = new string[] { VariableNames.Pressure };
break;
case PhysicsMode.LowMach:
ScalarFields = new string[] { VariableNames.Pressure, VariableNames.Temperature };
break;
case PhysicsMode.Multiphase:
ScalarFields = new string[] { VariableNames.Pressure, VariableNames.LevelSet };
break;
case PhysicsMode.Combustion:
ScalarFields = new string[] { VariableNames.Pressure, VariableNames.Temperature, VariableNames.MassFraction0, VariableNames.MassFraction1, VariableNames.MassFraction2, VariableNames.MassFraction3, VariableNames.MassFraction4 };
break;
case PhysicsMode.Helical:
ScalarFields = new string[] { VariableNames.u, VariableNames.v, VariableNames.w, VariableNames.Pressure };
return(ScalarFields);
case PhysicsMode.Viscoelastic:
ScalarFields = new string[] { VariableNames.Pressure, VariableNames.StressXX, VariableNames.StressXY, VariableNames.StressYY };
break;
case PhysicsMode.RANS:
ScalarFields = new string[] { VariableNames.Pressure, "k", "omega" }; // TODO physics mode for each turbulence model?
break;
case PhysicsMode.MixtureFraction:
ScalarFields = new string[] { VariableNames.Pressure, VariableNames.MixtureFraction };
break;
default:
throw new ArgumentException();
}
return(ArrayTools.Cat(VariableNames.VelocityVector(D), ScalarFields));
}
/// <summary>
/// Ctor
/// intended for use in the context of RANS turbulence model equations
/// </summary>
public LinearizedScalarConvection(int SpatDim, IncompressibleBoundaryCondMap BcMap, string TurbulentVariable, string TurbulentVariable0, string TurbulentVariable0Mean)
{
if (BcMap.PhysMode != PhysicsMode.RANS)
{
throw new ApplicationException("This Constructor is only intended for RANS turbulence model equations");
}
m_SpatialDimension = SpatDim;
m_bcmap = BcMap;
velFunction = new Func <double[], double, double> [SpatDim][];
for (int d = 0; d < SpatDim; d++)
{
velFunction[d] = m_bcmap.bndFunction[VariableNames.Velocity_d(d)];
}
scalarFunction = m_bcmap.bndFunction[TurbulentVariable];
m_ArgumentOrdering = new string[] { TurbulentVariable };
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim),
TurbulentVariable0, TurbulentVariable0Mean);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="SpatDim">Spatial dimension (either 2 or 3)</param>
/// <param name="BcMap"></param>
/// <param name="EoS">
/// Null for multiphase.
/// Has to be given for Low-Mach to calculate density.
/// </param>
public LinearizedScalarConvection(int SpatDim, IncompressibleBoundaryCondMap BcMap, MaterialLaw EoS)
{
m_SpatialDimension = SpatDim;
m_bcmap = BcMap;
velFunction = new Func <double[], double, double> [SpatDim][];
for (int d = 0; d < SpatDim; d++)
{
velFunction[d] = m_bcmap.bndFunction[VariableNames.Velocity_d(d)];
}
switch (BcMap.PhysMode)
{
case PhysicsMode.Multiphase:
scalarFunction = m_bcmap.bndFunction[VariableNames.LevelSet];
m_ArgumentOrdering = new string[] { VariableNames.LevelSet };
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim));
break;
case PhysicsMode.LowMach:
case PhysicsMode.Combustion:
scalarFunction = m_bcmap.bndFunction[VariableNames.Temperature];
m_ArgumentOrdering = new string[] { VariableNames.Temperature };
m_ParameterOrdering = ArrayTools.Cat(VariableNames.Velocity0Vector(SpatDim), VariableNames.Velocity0MeanVector(SpatDim),
VariableNames.Temperature0, VariableNames.Temperature0Mean);
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// flux at the boundary
/// </summary>
protected override double BorderEdgeFlux(ref CommonParamsBnd inp, double[] Uin)
{
IncompressibleBcType edgeType = m_bcmap.EdgeTag2Type[inp.EdgeTag];
switch (edgeType)
{
case IncompressibleBcType.Wall:
case IncompressibleBcType.NoSlipNeumann:
case IncompressibleBcType.FreeSlip:
case IncompressibleBcType.SlipSymmetry:
case IncompressibleBcType.NavierSlip_Linear:
case IncompressibleBcType.Velocity_Inlet: {
// Fluss am Rand: f(u[d]) = n∙v∙u[d]
// wobei n der Normalenvektor, v=(v1,v2) resp. v=(v1,v2,v3) der Linearisierungspunkt.
//
// Begründung: im Gegensatz zu obigem Code scheint dies besser zu funktionieren,
// wenn ein Offset (m_UseBoundaryVelocityParameter == true) addiert wird.
// Details: siehe Note 0022;
double r = 0.0;
double v1, v2, v3 = 0.0, u_d;
if (m_UseBoundaryVelocityParameter)
{
Debug.Assert(m_bcmap.PhysMode == PhysicsMode.LowMach || m_bcmap.PhysMode == PhysicsMode.Combustion || m_bcmap.PhysMode == PhysicsMode.Multiphase, "A boundary velocity is not implemented for variable density!");
u_d = Uin[0];
v1 = velFunction[inp.EdgeTag, 0](inp.X, inp.time) + inp.Parameters_IN[0 + 2 * m_SpatialDimension];
v2 = velFunction[inp.EdgeTag, 1](inp.X, inp.time) + inp.Parameters_IN[1 + 2 * m_SpatialDimension];
if (m_SpatialDimension == 3)
{
v3 = velFunction[inp.EdgeTag, 2](inp.X, inp.time) + inp.Parameters_IN[2 + 2 * m_SpatialDimension];
}
r += u_d * (v1 * inp.Normale[0] + v2 * inp.Normale[1]);
if (m_SpatialDimension == 3)
{
r += u_d * v3 * inp.Normale[2];
}
}
else
{
// Setup params
// ============
Foundation.CommonParams inp2;
inp2.GridDat = inp.GridDat;
inp2.Normale = inp.Normale;
inp2.iEdge = inp.iEdge;
inp2.Parameters_IN = inp.Parameters_IN;
inp2.X = inp.X;
inp2.time = inp.time;
// Dirichlet value for velocity
// ============================
double Uout = velFunction[inp.EdgeTag, m_component](inp.X, inp.time);
// Specify Parameters_OUT
// ======================
inp2.Parameters_OUT = new double[inp.Parameters_IN.Length];
// Outer values for Velocity and VelocityMean
for (int j = 0; j < m_SpatialDimension; j++)
{
inp2.Parameters_OUT[j] = velFunction[inp.EdgeTag, j](inp.X, inp.time);
// Velocity0MeanVectorOut is set to zero, i.e. always LambdaIn is used.
inp2.Parameters_OUT[m_SpatialDimension + j] = 0.0;
}
// Outer values for Scalar and ScalarMean
switch (m_bcmap.PhysMode)
{
case PhysicsMode.Viscoelastic:
case PhysicsMode.Incompressible:
break;
case PhysicsMode.LowMach:
case PhysicsMode.Multiphase: {
// opt1:
switch (edgeType)
{
case IncompressibleBcType.Velocity_Inlet:
case IncompressibleBcType.Wall:
inp2.Parameters_OUT[2 * m_SpatialDimension] = scalarFunction[inp.EdgeTag](inp.X, inp.time);
break;
case IncompressibleBcType.NoSlipNeumann:
inp2.Parameters_OUT[2 * m_SpatialDimension] = inp2.Parameters_IN[2 * m_SpatialDimension];
break;
default:
throw new ApplicationException();
}
// opt2:
// Inner values are used for the Scalar variable (even at Dirichlet boundaries of the Scalar variable).
// The Dirichlet value for the Scalar variable will be used while solving the Scalar equation, but not in the momentum equation.
//inp2.Parameters_OUT[2 * m_SpatialDimension] = inp2.Parameters_IN[2 * m_SpatialDimension];
// Use inner value for ScalarMean, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + 1] = inp.Parameters_IN[2 * m_SpatialDimension + 1];
break;
}
case PhysicsMode.Combustion: {
switch (edgeType)
{
case IncompressibleBcType.Velocity_Inlet:
// opt1: (using Dirichlet values)
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants + 1; n++)
{
// opt1: (using Dirichlet values)
inp2.Parameters_OUT[2 * m_SpatialDimension + n] = m_bcmap.bndFunction[VariableNames.MassFraction_n(n - 1)][inp.EdgeTag](inp.X, inp.time);
}
break;
case IncompressibleBcType.Wall:
// opt1: (using Dirichlet values for the temperature)
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants + 1; n++)
{
// using inner values for the mass fractions
inp2.Parameters_OUT[2 * m_SpatialDimension + n] = inp2.Parameters_IN[2 * m_SpatialDimension + n];
}
break;
case IncompressibleBcType.NoSlipNeumann:
for (int n = 0; n < NumberOfReactants + 1; n++)
{
// using inner values for the temperature and the mass fractions
inp2.Parameters_OUT[2 * m_SpatialDimension + n] = inp2.Parameters_IN[2 * m_SpatialDimension + n];
}
break;
default:
throw new ApplicationException();
}
for (int n = 0; n < NumberOfReactants + 1; n++)
{
// Use inner value for mean scalar input parameters, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + NumberOfReactants + 1 + n] = inp.Parameters_IN[2 * m_SpatialDimension + NumberOfReactants + 1 + n];
}
break;
}
default:
throw new NotImplementedException("PhysicsMode not implemented");
}
// Calculate BorderEdgeFlux as InnerEdgeFlux
// =========================================
r = InnerEdgeFlux(ref inp2, Uin, new double[] { Uout });
}
return(r);
}
case IncompressibleBcType.Pressure_Dirichlet:
case IncompressibleBcType.Outflow:
case IncompressibleBcType.Pressure_Outlet: {
double r = 0.0;
double u1, u2, u3 = 0, u_d;
if (m_UseBoundaryVelocityParameter)
{
Debug.Assert(m_bcmap.PhysMode == PhysicsMode.LowMach || m_bcmap.PhysMode == PhysicsMode.Combustion || m_bcmap.PhysMode == PhysicsMode.Multiphase, "A boundary velocity is not implemented for variable density!");
u_d = Uin[0];
u1 = inp.Parameters_IN[0] + inp.Parameters_IN[0 + 2 * m_SpatialDimension];
u2 = inp.Parameters_IN[1] + inp.Parameters_IN[1 + 2 * m_SpatialDimension];
if (m_SpatialDimension == 3)
{
u3 = inp.Parameters_IN[2] + inp.Parameters_IN[2 + 2 * m_SpatialDimension];
}
}
else
{
u_d = Uin[0];
u1 = inp.Parameters_IN[0];
u2 = inp.Parameters_IN[1];
if (m_SpatialDimension == 3)
{
u3 = inp.Parameters_IN[2];
}
}
r += u_d * (u1 * inp.Normale[0] + u2 * inp.Normale[1]);
if (m_SpatialDimension == 3)
{
r += u_d * u3 * inp.Normale[2];
}
if (m_bcmap.PhysMode == PhysicsMode.LowMach || m_bcmap.PhysMode == PhysicsMode.Multiphase)
{
double rho = EoS.GetDensity(inp.Parameters_IN[2 * m_SpatialDimension]);
r *= rho;
}
if (m_bcmap.PhysMode == PhysicsMode.Combustion)
{
double[] args = new double[NumberOfReactants + 1];
for (int n = 0; n < NumberOfReactants + 1; n++)
{
args[n] = inp.Parameters_IN[2 * m_SpatialDimension + n];
}
double rho = EoS.GetDensity(args);
r *= rho;
}
return(r);
}
default:
throw new NotImplementedException("Boundary condition not implemented!");
}
}
protected override double BorderEdgeFlux(ref Foundation.CommonParamsBnd inp, double[] Uin)
{
double res = 0.0;
IncompressibleBcType edgeType = Bcmap.EdgeTag2Type[inp.EdgeTag];
switch (edgeType)
{
case IncompressibleBcType.Wall:
case IncompressibleBcType.NoSlipNeumann: {
res = 0.0;
break;
}
case IncompressibleBcType.Velocity_Inlet: {
double TemperatureOut = 0.0;
double Uout = VelFunction[inp.EdgeTag](inp.X, inp.time);
switch (Bcmap.PhysMode)
{
case PhysicsMode.LowMach:
case PhysicsMode.Multiphase: {
// opt1:
TemperatureOut = Bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
res = EoS.GetDensity(TemperatureOut) * Uout * inp.Normal[Component];
// opt2:
//double TemperatureIN = inp.Parameters_IN[0];
//double rhoIn = EoS.GetDensity(TemperatureIN);
//res = rhoIn * Uout * inp.Normale[Component];
break;
}
case PhysicsMode.Combustion:
// opt1:
TemperatureOut = Bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
double[] args = new double[NumberOfReactants + 1];
args[0] = TemperatureOut;
for (int n = 1; n < NumberOfReactants + 1; n++)
{
args[n] = Bcmap.bndFunction[VariableNames.MassFraction_n(n - 1)][inp.EdgeTag](inp.X, inp.time);
}
res = EoS.GetDensity(args) * Uout * inp.Normal[Component];
break;
case PhysicsMode.Incompressible:
res = Uout * inp.Normal[Component];
break;
default:
throw new ApplicationException("PhysicsMode not implemented");
}
}
break;
case IncompressibleBcType.Pressure_Outlet: {
switch (Bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
res = Uin[0] * inp.Normal[Component];
break;
case PhysicsMode.LowMach:
case PhysicsMode.Multiphase:
res = EoS.GetDensity(inp.Parameters_IN[0]) * Uin[0] * inp.Normal[Component];
break;
case PhysicsMode.Combustion:
res = EoS.GetDensity(inp.Parameters_IN) * Uin[0] * inp.Normal[Component];
break;
default:
throw new ApplicationException("PhysicsMode not implemented");
}
}
break;
default:
throw new NotImplementedException("Boundary condition not implemented!");
}
return(res);
}
/// <summary>
/// Ctor for low Mach number flows.
/// </summary>
/// <param name="Component"></param>
/// <param name="Bcmap"></param>
/// <param name="EoS"></param>
public Divergence_CentralDifference(int Component, IncompressibleBoundaryCondMap Bcmap, MaterialLaw EoS, int NumberOfReactants = -1)
: this(Component, Bcmap)
{
this.EoS = EoS;
switch (Bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
case PhysicsMode.Multiphase:
throw new ApplicationException("Wrong constructor");
case PhysicsMode.LowMach:
this.m_ParamterOrdering = new string[] { VariableNames.Temperature0 };
break;
case PhysicsMode.Combustion:
this.m_ParamterOrdering = ArrayTools.Cat(new string[] { VariableNames.Temperature0 }, VariableNames.MassFractions0(NumberOfReactants));
this.NumberOfReactants = NumberOfReactants;
if (NumberOfReactants == -1)
{
throw new ArgumentException("NumberOfReactants must be specified for combustion flows.");
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor for incompressible flows.
/// </summary>
/// <param name="Component"></param>
/// <param name="Bcmap"></param>
public Divergence_CentralDifference(int Component, IncompressibleBoundaryCondMap Bcmap)
{
this.Component = Component;
this.Bcmap = Bcmap;
this.VelFunction = Bcmap.bndFunction[VariableNames.Velocity_d(Component)];
}
double BorderEdgeFlux(ref Foundation.CommonParamsBnd inp, double[] Uin)
{
double res = 0.0;
IncompressibleBcType edgeType = Bcmap.EdgeTag2Type[inp.EdgeTag];
double[] DensityArgumentsIn;
switch (edgeType)
{
case IncompressibleBcType.Wall:
case IncompressibleBcType.NoSlipNeumann:
res = 0.0;
break;
case IncompressibleBcType.Velocity_Inlet: {
double TemperatureOut = 0.0;
double Uout = VelFunction[inp.EdgeTag](inp.X, inp.time);
switch (Bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
res = Uout * inp.Normal[Component];
break;
case PhysicsMode.MixtureFraction:
// opt1:
double Zout = Bcmap.bndFunction[VariableNames.MixtureFraction][inp.EdgeTag](inp.X, inp.time);
res = EoS.getDensityFromZ(Zout) * Uout * inp.Normal[Component];
break;
case PhysicsMode.LowMach:
case PhysicsMode.Multiphase: {
// opt1:
TemperatureOut = Bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
res = EoS.GetDensity(TemperatureOut) * Uout * inp.Normal[Component];
// opt2:
//double TemperatureIN = inp.Parameters_IN[0];
//double rhoIn = EoS.GetDensity(TemperatureIN);
//res = rhoIn * Uout * inp.Normale[Component];
break;
}
case PhysicsMode.Combustion: {
// opt1:
TemperatureOut = Bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
double[] argsa = new double[NumberOfSpecies - 1 + 1];
argsa[0] = TemperatureOut;
for (int n = 1; n < NumberOfSpecies; n++)
{
argsa[n] = Bcmap.bndFunction[VariableNames.MassFraction_n(n - 1)][inp.EdgeTag](inp.X, inp.time);
}
res = EoS.GetDensity(argsa) * Uout * inp.Normal[Component];
break;
}
default:
throw new ApplicationException("PhysicsMode not implemented");
}
}
break;
case IncompressibleBcType.Pressure_Dirichlet:
case IncompressibleBcType.Pressure_Outlet: {
switch (Bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
res = Uin[Component] * inp.Normal[Component];
break;
case PhysicsMode.MixtureFraction:
double Zin = Uin[inp.D];
res = EoS.getDensityFromZ(Zin) * Uin[Component] * inp.Normal[Component];
break;
case PhysicsMode.LowMach:
case PhysicsMode.Multiphase:
DensityArgumentsIn = Uin.GetSubVector(m_SpatialDimension, 1); // Only TemperatureIn
res = EoS.GetDensity(DensityArgumentsIn) * Uin[Component] * inp.Normal[Component];
break;
case PhysicsMode.Combustion:
DensityArgumentsIn = Uin.GetSubVector(m_SpatialDimension, NumberOfSpecies);
res = EoS.GetDensity(DensityArgumentsIn) * Uin[Component] * inp.Normal[Component];
break;
default:
throw new ApplicationException("PhysicsMode not implemented");
}
}
break;
default:
throw new NotImplementedException("Boundary condition not implemented!");
}
return(res);
}
/// <summary>
/// flux at the boundary
/// </summary>
protected override double BorderEdgeFlux(ref Foundation.CommonParamsBnd inp, double[] Uin)
{
IncompressibleBcType edgeType = m_bcmap.EdgeTag2Type[inp.EdgeTag];
switch (edgeType)
{
case IncompressibleBcType.Wall: {
if ((edgeType == IncompressibleBcType.Wall) && (m_bcmap.PhysMode == PhysicsMode.Multiphase))
{
throw new ApplicationException("Use NoSlipNeumann boundary condition for multiphase flows instead of Wall.");
}
double r = 0.0;
// Setup params
// ============
Foundation.CommonParams inp2;
inp2.GridDat = inp.GridDat;
inp2.Normal = inp.Normal;
inp2.iEdge = inp.iEdge;
inp2.Parameters_IN = inp.Parameters_IN;
inp2.X = inp.X;
inp2.time = inp.time;
inp2.jCellIn = inp.jCellIn;
inp2.jCellOut = int.MinValue;
// Boundary values for Parameters
// ==============================
inp2.Parameters_OUT = new double[inp.Parameters_IN.Length];
// Velocity
for (int j = 0; j < m_SpatialDimension; j++)
{
// opt1:
inp2.Parameters_OUT[j] = m_bcmap.bndFunction[VariableNames.Velocity_d(j)][inp.EdgeTag](inp.X, inp.time);
// opt2: inner values
//inp2.Parameters_OUT[j] = inp2.Parameters_IN[j];
// Velocity0MeanVectorOut is set to zero, i.e. always LambdaIn is used.
inp2.Parameters_OUT[m_SpatialDimension + j] = 0.0;
}
// Skalar (e.g. temperature or MassFraction)
switch (m_bcmap.PhysMode)
{
case PhysicsMode.LowMach: {
// opt1:
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
// opt2: inner values
//inp2.Parameters_OUT[2 * m_SpatialDimension] = inp2.Parameters_IN[2 * m_SpatialDimension];
// Use inner value for TemperatureMean, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + 1] = inp.Parameters_IN[2 * m_SpatialDimension + 1];
break;
}
case PhysicsMode.Combustion: {
// opt1: (using Dirichlet values)
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants + 1; n++)
{
//Using inner values
inp2.Parameters_OUT[2 * m_SpatialDimension + n] = inp.Parameters_IN[2 * m_SpatialDimension + n];
}
for (int n = 0; n < NumberOfReactants + 1; n++)
{
// Use inner value for mean scalar input parameters, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + NumberOfReactants + 1 + n] = inp.Parameters_IN[2 * m_SpatialDimension + NumberOfReactants + 1 + n];
}
break;
}
case PhysicsMode.Multiphase:
break;
default:
throw new NotImplementedException();
}
// Dirichlet value for scalar
// ==========================
double[] Uout = new double[] { m_bcmap.bndFunction[Argument][inp.EdgeTag](inp.X, inp.time) };
// Calculate BorderEdgeFlux as InnerEdgeFlux
// =========================================
r = InnerEdgeFlux(ref inp2, Uin, Uout);
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
case IncompressibleBcType.Velocity_Inlet: {
if ((edgeType == IncompressibleBcType.Wall) && (m_bcmap.PhysMode == PhysicsMode.Multiphase))
{
throw new ApplicationException("Use NoSlipNeumann boundary condition for multiphase flows instead of Wall.");
}
double r = 0.0;
// Setup params
// ============
Foundation.CommonParams inp2;
inp2.GridDat = inp.GridDat;
inp2.Normal = inp.Normal;
inp2.iEdge = inp.iEdge;
inp2.Parameters_IN = inp.Parameters_IN;
inp2.X = inp.X;
inp2.time = inp.time;
inp2.jCellIn = inp.jCellIn;
inp2.jCellOut = int.MinValue;
// Boundary values for Parameters
// ==============================
inp2.Parameters_OUT = new double[inp.Parameters_IN.Length];
// Velocity
for (int j = 0; j < m_SpatialDimension; j++)
{
// opt1:
inp2.Parameters_OUT[j] = m_bcmap.bndFunction[VariableNames.Velocity_d(j)][inp.EdgeTag](inp.X, inp.time);
// opt2: inner values
//inp2.Parameters_OUT[j] = inp2.Parameters_IN[j];
// Velocity0MeanVectorOut is set to zero, i.e. always LambdaIn is used.
inp2.Parameters_OUT[m_SpatialDimension + j] = 0.0;
}
// Skalar (e.g. temperature or MassFraction)
switch (m_bcmap.PhysMode)
{
case PhysicsMode.LowMach: {
// opt1:
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
// opt2: inner values
//inp2.Parameters_OUT[2 * m_SpatialDimension] = inp2.Parameters_IN[2 * m_SpatialDimension];
// Use inner value for TemperatureMean, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + 1] = inp.Parameters_IN[2 * m_SpatialDimension + 1];
break;
}
case PhysicsMode.Combustion: {
// opt1: (using Dirichlet values)
inp2.Parameters_OUT[2 * m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants + 1; n++)
{
// opt1: (using Dirichlet values)
inp2.Parameters_OUT[2 * m_SpatialDimension + n] = m_bcmap.bndFunction[VariableNames.MassFraction_n(n - 1)][inp.EdgeTag](inp.X, inp.time);
}
for (int n = 0; n < NumberOfReactants + 1; n++)
{
// Use inner value for mean scalar input parameters, i.e. LambdaIn is used.
inp2.Parameters_OUT[2 * m_SpatialDimension + NumberOfReactants + 1 + n] = inp.Parameters_IN[2 * m_SpatialDimension + NumberOfReactants + 1 + n];
}
break;
}
case PhysicsMode.Multiphase:
break;
default:
throw new NotImplementedException();
}
// Dirichlet value for scalar
// ==========================
double[] Uout = new double[] { m_bcmap.bndFunction[Argument][inp.EdgeTag](inp.X, inp.time) };
// Calculate BorderEdgeFlux as InnerEdgeFlux
// =========================================
r = InnerEdgeFlux(ref inp2, Uin, Uout);
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
case IncompressibleBcType.Pressure_Dirichlet:
case IncompressibleBcType.Outflow:
case IncompressibleBcType.Pressure_Outlet:
case IncompressibleBcType.NoSlipNeumann: {
double r = 0.0;
double u1, u2, u3 = 0;
u1 = inp.Parameters_IN[0];
u2 = inp.Parameters_IN[1];
r += Uin[0] * (u1 * inp.Normal[0] + u2 * inp.Normal[1]);
if (m_SpatialDimension == 3)
{
u3 = inp.Parameters_IN[2];
r += Uin[0] * u3 * inp.Normal[2];
}
if (m_bcmap.PhysMode == PhysicsMode.LowMach)
{
double rho = EoS.GetDensity(inp.Parameters_IN[2 * m_SpatialDimension]);
r *= rho;
}
if (m_bcmap.PhysMode == PhysicsMode.Combustion)
{
double[] args = new double[NumberOfReactants + 1];
for (int n = 0; n < NumberOfReactants + 1; n++)
{
args[n] = inp.Parameters_IN[2 * m_SpatialDimension + n];
}
double rho = EoS.GetDensity(args);
r *= rho;
}
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
default:
throw new NotImplementedException("Boundary condition not implemented!");
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="SpatDim">Spatial dimension (either 2 or 3)</param>
/// <param name="NumberOfReactants"></param>
/// <param name="BcMap"></param>
/// <param name="EoS">Null for multiphase. Has to be given for Low-Mach and combustion to calculate density.</param>
/// <param name="idx">Index of scalar in array, </param>
/// <param name="Argument">Variable name of the argument (e.g. "Temperature" or "MassFraction0")</param>
public LinearizedScalarConvection2Jacobi(int SpatDim, int NumberOfReactants, IncompressibleBoundaryCondMap BcMap, MaterialLaw EoS, int idx)
{
this.NumberOfReactants = NumberOfReactants;
m_SpatialDimension = SpatDim;
m_bcmap = BcMap;
argumentIndex = m_SpatialDimension + idx;
velFunction = new Func <double[], double, double> [GridCommons.FIRST_PERIODIC_BC_TAG, SpatDim];
for (int d = 0; d < SpatDim; d++)
{
velFunction.SetColumn(m_bcmap.bndFunction[VariableNames.Velocity_d(d)], d);
}
switch (BcMap.PhysMode)
{
case PhysicsMode.Multiphase:
//this.Argument = VariableNames.LevelSet;
m_ArgumentOrdering = new string[] { VariableNames.LevelSet };
break;
case PhysicsMode.LowMach:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.Temperature); // VelocityX,VelocityY,(VelocityZ), Temperature as variables.
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
case PhysicsMode.MixtureFraction:
;
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.MixtureFraction); // VelocityX,VelocityY,(VelocityZ), MixtureFraction as variables.
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
case PhysicsMode.Combustion:
m_ArgumentOrdering = ArrayTools.Cat(VariableNames.VelocityVector(SpatDim), VariableNames.Temperature, VariableNames.MassFractions(NumberOfReactants - 1)); // u,v,w,T, Y0,Y1,Y2,Y3 as variables (Y4 is calculated as Y4 = 1- (Y0+Y1+Y2+Y3)
if (EoS == null)
{
throw new ApplicationException("EoS has to be given for Low-Mach flows to calculate density.");
}
else
{
this.EoS = EoS;
}
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Ctor for incompressible flows.
/// </summary>
/// <param name="component">component of the divergence</param>
/// <param name="bcmap"></param>
public Divergence_DerivativeSource_Flux(int component, IncompressibleBoundaryCondMap bcmap) //, double PresPenalty2) {
{
this.component = component;
this.bcmap = bcmap;
this.bndFunction = bcmap.bndFunction[VariableNames.Velocity_d(component)];
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="ReactionRateConstants">constants[0]=PreExpFactor, constants[1]=ActivationTemperature, constants[2]=MassFraction0Exponent, constants[3]=MassFraction1Exponent</param>
/// <param name="StoichiometricCoefficients"></param>
/// <param name="MolarMasses">Array of molar masses. 0 Fuel. 1 Oxidizer, 2 to ns products.</param>
/// <param name="EoS">MaterialLawCombustion</param>
/// <param name="NumberOfReactants">The number of reactants (i.e. ns)</param>
/// <param name="SpeciesIndex">Index of the species being balanced. (I.e. 0 for fuel, 1 for oxidizer, 2 for CO2, 3 for water)</param>
public ReactionSpeciesSourceJacobi(double[] ReactionRateConstants, double[] StoichiometricCoefficients, double[] MolarMasses, MaterialLawCombustion EoS, int NumberOfReactants, int SpeciesIndex, double TRef, double cpRef, bool VariableOneStepParameters)
{
m_ArgumentOrdering = ArrayTools.Cat(new string[] { VariableNames.Temperature }, VariableNames.MassFractions(NumberOfReactants - 1));// Y4 is not a variable!!!!;
this.StoichiometricCoefficients = StoichiometricCoefficients;
this.ReactionRateConstants = ReactionRateConstants;
this.SpeciesIndex = SpeciesIndex;
this.MolarMasses = MolarMasses;
this.EoS = EoS;
this.m_Da = ReactionRateConstants[0];
this.TRef = TRef;
this.cpRef = cpRef;
this.VariableOneStepParameters = VariableOneStepParameters;
}
/// <summary>
/// flux at the boundary
/// </summary>
double BorderEdgeFlux(ref Foundation.CommonParamsBnd inp, double[] Uin)
{
IncompressibleBcType edgeType = m_bcmap.EdgeTag2Type[inp.EdgeTag];
switch (edgeType)
{
case IncompressibleBcType.Wall: {
if ((edgeType == IncompressibleBcType.Wall) && (m_bcmap.PhysMode == PhysicsMode.Multiphase))
{
throw new ApplicationException("Use NoSlipNeumann boundary condition for multiphase flows instead of Wall.");
}
double r = 0.0;
// Setup params
// ============
Foundation.CommonParams inp2;
inp2.GridDat = inp.GridDat;
inp2.Normal = inp.Normal;
inp2.iEdge = inp.iEdge;
inp2.Parameters_IN = inp.Parameters_IN;
inp2.X = inp.X;
inp2.time = inp.time;
inp2.jCellIn = inp.jCellIn;
inp2.jCellOut = int.MinValue;
// Boundary values for Parameters
// ==============================
inp2.Parameters_OUT = new double[inp.Parameters_IN.Length];
// Dirichlet values for scalars and Velocities
// ==========================
double[] Uout = new double[Uin.Length];
//Velocity
for (int i = 0; i < m_SpatialDimension; i++)
{
Uout[i] = m_bcmap.bndFunction[VariableNames.Velocity_d(i)][inp.EdgeTag](inp.X, inp.time);
}
switch (m_bcmap.PhysMode)
{
case PhysicsMode.MixtureFraction:
// opt1:
//inp2.Parameters_OUT = inp.Parameters_IN;
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.MixtureFraction][inp.EdgeTag](inp.X, inp.time);
break;
case PhysicsMode.LowMach: {
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
break;
}
case PhysicsMode.Combustion: {
// opt1: (using Dirichlet values)
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants - 1 + 1; n++)
{
//Using inner values for species
Uout[m_SpatialDimension + n] = Uin[m_SpatialDimension + n];
}
break;
}
case PhysicsMode.Multiphase:
break;
default:
throw new NotImplementedException();
}
// Calculate BorderEdgeFlux as InnerEdgeFlux
// =========================================
r = InnerEdgeFlux(ref inp2, Uin, Uout);
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
case IncompressibleBcType.Velocity_Inlet: {
if ((edgeType == IncompressibleBcType.Wall) && (m_bcmap.PhysMode == PhysicsMode.Multiphase))
{
throw new ApplicationException("Use NoSlipNeumann boundary condition for multiphase flows instead of Wall.");
}
double r = 0.0;
// Setup params
// ============
Foundation.CommonParams inp2;
inp2.GridDat = inp.GridDat;
inp2.Normal = inp.Normal;
inp2.iEdge = inp.iEdge;
inp2.Parameters_IN = inp.Parameters_IN;
inp2.X = inp.X;
inp2.time = inp.time;
inp2.jCellIn = inp.jCellIn;
inp2.jCellOut = int.MinValue;
// Boundary values for Parameters
// ==============================
inp2.Parameters_OUT = new double[inp.Parameters_IN.Length];
double[] Uout = new double[Uin.Length];
// Velocity
for (int j = 0; j < m_SpatialDimension; j++)
{
// opt1:
Uout[j] = m_bcmap.bndFunction[VariableNames.Velocity_d(j)][inp.EdgeTag](inp.X, inp.time);
}
// Skalar (e.g. temperature or MassFraction)
switch (m_bcmap.PhysMode)
{
case PhysicsMode.MixtureFraction: {
// opt1:
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.MixtureFraction][inp.EdgeTag](inp.X, inp.time);
break;
}
case PhysicsMode.LowMach: {
// opt1:
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
// opt2: inner values
//inp2.Parameters_OUT[2 * m_SpatialDimension] = inp2.Parameters_IN[2 * m_SpatialDimension];
break;
}
case PhysicsMode.Combustion: {
// opt1: (using Dirichlet values)
Uout[m_SpatialDimension] = m_bcmap.bndFunction[VariableNames.Temperature][inp.EdgeTag](inp.X, inp.time);
for (int n = 1; n < NumberOfReactants; n++)
{
// opt1: (using Dirichlet values)
Uout[m_SpatialDimension + n] = m_bcmap.bndFunction[VariableNames.MassFraction_n(n - 1)][inp.EdgeTag](inp.X, inp.time);
}
break;
}
case PhysicsMode.Multiphase:
break;
default:
throw new NotImplementedException();
}
// Calculate BorderEdgeFlux as InnerEdgeFlux
// =========================================
r = InnerEdgeFlux(ref inp2, Uin, Uout);
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
case IncompressibleBcType.Pressure_Dirichlet:
case IncompressibleBcType.Outflow:
case IncompressibleBcType.Pressure_Outlet:
case IncompressibleBcType.NoSlipNeumann: {
double r = 0.0;
double u1, u2, u3 = 0;
u1 = Uin[0];
u2 = Uin[1];
r += Uin[argumentIndex] * (u1 * inp.Normal[0] + u2 * inp.Normal[1]);
if (m_SpatialDimension == 3)
{
u3 = Uin[2];
r += Uin[argumentIndex] * u3 * inp.Normal[2];
}
double rho = 1.0;
switch (m_bcmap.PhysMode)
{
case PhysicsMode.Incompressible:
break;
case PhysicsMode.MixtureFraction:
rho = EoS.getDensityFromZ(Uin[inp.D]);
break;
case PhysicsMode.LowMach:
rho = EoS.GetDensity(Uin[argumentIndex]);
break;
case PhysicsMode.Combustion:
double[] args = ArrayTools.GetSubVector(Uin, m_SpatialDimension, NumberOfReactants - 1 + 1);
rho = EoS.GetDensity(args);
break;
default:
throw new NotImplementedException("not implemented physmode");
}
r *= rho;
if (double.IsNaN(r))
{
throw new NotFiniteNumberException();
}
return(r);
}
default:
throw new NotImplementedException("Boundary condition not implemented!");
}
}