/// <summary>
/// Ctor.
/// </summary>
/// <param name="solverConf"></param>
/// <param name="_sparseSolver"></param>
/// <param name="MatAsmblyCorrector"></param>
/// <param name="VelocityDivergence"></param>
/// <param name="Velocity_Intrmed"></param>
/// <param name="DivB4"></param>
/// <param name="BDF"></param>
/// <param name="Temperature"></param>
/// <param name="EoS"></param>
public LowMachSolverCorrector(SolverConfiguration solverConf, ISparseSolver _sparseSolver,
SIMPLEMatrixAssembly MatAsmblyCorrector,
SIMPLEOperator[] VelocityDivergence, VectorField <SinglePhaseField> Velocity_Intrmed, SinglePhaseField DivB4,
BDFScheme BDF, ScalarFieldHistory <SinglePhaseField> Temperature, MaterialLaw EoS, double[] RHSManuDivKontiOperatorAffine = null)
: base(solverConf, _sparseSolver)
{
this.MatAsmblyCorrector = MatAsmblyCorrector;
this.VelocityDivergence = VelocityDivergence;
this.Velocity_Intrmed = Velocity_Intrmed;
this.DivB4 = DivB4;
this.BDF = BDF;
this.Temperature = Temperature;
this.EoS = EoS;
this.RHSManuDivKontiOperatorAffine = RHSManuDivKontiOperatorAffine;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="GridDat"></param>
/// <param name="Temperature"></param>
/// <param name="EoS"></param>
/// <param name="edgeTagNames"></param>
public NusseltNumber(IGridData GridDat, SinglePhaseField Temperature, MaterialLaw EoS, string[] edgeTagNames)
{
this.GridDat = GridDat;
this.Temperature = Temperature;
//Basis BasisDerivative = new Basis(GridDat, Temperature.Basis.Degree - 1);
Basis BasisDerivative = new Basis(GridDat, Temperature.Basis.Degree);
dTdx = new SinglePhaseField(BasisDerivative);
dTdy = new SinglePhaseField(BasisDerivative);
NusseltIntegrals = new EdgeIntegral[edgeTagNames.Length];
Nusselt = new double[edgeTagNames.Length];
for (int bc = 0; bc < edgeTagNames.Length; bc++)
{
NusseltIntegrals[bc] = new EdgeIntegral((BoSSS.Foundation.Grid.Classic.GridData)GridDat,
edgeTagNames[bc],
new NusseltFlux2D(EoS),
new CoordinateMapping(dTdx, dTdy, Temperature),
20);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="solverConfig"></param>
/// <param name="_sparseSolver"></param>
/// <param name="DensityMatrix"></param>
/// <param name="MatAsmblyTemperature"></param>
/// <param name="MatAsmblyTemperatureApprox"></param>
/// <param name="Temperature"></param>
/// <param name="BDF"></param>
/// <param name="EoS"></param>
/// <param name="ThermodynamicPressure"></param>
public LowMachSolverTemperature(SolverConfiguration solverConfig, ISparseSolver _sparseSolver,
BlockDiagonalMatrix DensityMatrix, SIMPLEMatrixAssembly MatAsmblyTemperature, SIMPLEMatrixAssembly MatAsmblyTemperatureApprox,
ScalarFieldHistory <SinglePhaseField> Temperature,
BDFScheme BDF, MaterialLaw EoS,
ScalarFieldHistory <SinglePhaseField> ThermodynamicPressure)
: base(solverConfig, _sparseSolver)
{
this.DensityMatrix = DensityMatrix;
this.MatAsmblyTemperature = MatAsmblyTemperature;
this.MatAsmblyTemperatureApprox = MatAsmblyTemperatureApprox;
LowMachSIMPLEControl lowMachControl = solverConfig.Control as LowMachSIMPLEControl;
this.ModeRelaxTemperature = lowMachControl.RelaxationModeTemperature;
this.RelaxFactor = (1.0 - lowMachControl.RelexationFactorTemperature) / lowMachControl.RelexationFactorTemperature;
this.Temperature = Temperature;
this.BDF = BDF;
this.EoS = EoS;
this.gamma = lowMachControl.Gamma;
this.ThermodynamicPressure = ThermodynamicPressure;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="solverConf"></param>
/// <param name="_sparseSolver"></param>
/// <param name="DensityMatrix"></param>
/// <param name="MatAsmblyPredictor"></param>
/// <param name="MatAsmblyPredictorApprox"></param>
/// <param name="PressureGradient"></param>
/// <param name="Pressure"></param>
/// <param name="MatAsmblyViscSplit"></param>
/// <param name="BuoyantForce"></param>
/// <param name="Velocity"></param>
/// <param name="Scalar"></param>
/// <param name="EoS"></param>
/// <param name="BDF"></param>
public VariableDensitySolverPredictor(SolverConfiguration solverConf, ISparseSolver _sparseSolver,
BlockDiagonalMatrix DensityMatrix, SIMPLEMatrixAssembly MatAsmblyPredictor, SIMPLEMatrixAssembly MatAsmblyPredictorApprox,
SIMPLEOperator[] PressureGradient, SinglePhaseField Pressure,
SIMPLEMatrixAssembly[,] MatAsmblyViscSplit, IEvaluatorNonLin[] BuoyantForce,
VectorFieldHistory <SinglePhaseField> Velocity, ScalarFieldHistory <SinglePhaseField> Scalar, MaterialLaw EoS, BDFScheme BDF)
: base(solverConf, _sparseSolver)
{
m_DensityMatrix = DensityMatrix;
m_MatAsmblyPredictor = MatAsmblyPredictor;
m_MatAsmblyPredictorApprox = MatAsmblyPredictorApprox;
m_PressureGradient = PressureGradient;
m_Pressure = Pressure;
m_MatAsmblyViscSplit = MatAsmblyViscSplit;
m_BuoyantForceEvaluator = BuoyantForce;
m_Velocity = Velocity;
m_Scalar = Scalar;
m_EoS = EoS;
m_RelaxFactor = (1.0 - base.m_solverConf.Control.RelexationFactorVelocity) / base.m_solverConf.Control.RelexationFactorVelocity;
m_BDF = BDF;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="GridDat"></param>
/// <param name="VelocityBasis"></param>
/// <param name="PressureBasis"></param>
/// <param name="EoS"></param>
/// <param name="Scalar"></param>
public VariableMatrices(GridData GridDat, Basis VelocityBasis, Basis PressureBasis, MaterialLaw EoS, params SinglePhaseField[] Scalar)
{
// Construct matrices
m_Rho = new QuadratureMatrix_Rho(VelocityBasis, GridDat, EoS, Scalar);
// Initialize matrices
m_Rho.Update();
}
/// <summary>
/// ctor; parameter documentation see <see cref="swipViscosityBase.swipViscosityBase"/>.
/// </summary>
public swipViscosity_Term1_variante(double _penalty, int iComp, int D, IncompressibleBoundaryCondMap bcmap,
ViscosityOption _ViscosityMode, double constantViscosityValue = double.NaN, double reynolds = double.NaN, MaterialLaw EoS = null)
: base(_penalty, iComp, D, bcmap, _ViscosityMode, constantViscosityValue, reynolds, EoS)
{
}
/// <summary>
/// Update scalar field variables after solving scalar equation.
/// </summary>
/// <param name="SolverConf"></param>
/// <param name="ModeRelaxScalar"></param>
/// <param name="relax_scalar"></param>
/// <param name="Scalar"></param>
/// <param name="ScalarRes"></param>
/// <param name="ScalarMean"></param>
/// <param name="Rho"></param>
/// <param name="Eta"></param>
/// <param name="RhoMatrix"></param>
/// <param name="EoS"></param>
/// <param name="ThermodynamicPressure">Null for multiphase flows.</param>
public static void UpdateScalarFieldVariables(SIMPLEControl SolverConf, RelaxationTypes ModeRelaxScalar, double relax_scalar,
ScalarFieldHistory <SinglePhaseField> Scalar, SinglePhaseField ScalarRes, SinglePhaseField ScalarMean,
SinglePhaseField Rho, SinglePhaseField Eta, QuadratureMatrix RhoMatrix, MaterialLaw EoS,
SinglePhaseField ThermodynamicPressure, bool UpdateRhoVisc = true)
{
using (new FuncTrace()) {
// Explicit Under-Relaxation of scalar variable
// ============================================
if (ModeRelaxScalar == RelaxationTypes.Explicit)
{
// phi = alpha * phi_new + (1-alpha) * phi_old
Scalar.Current.Scale(relax_scalar);
Scalar.Current.Acc((1.0 - relax_scalar), ScalarRes);
}
// Scalar residual
// ===============
ScalarRes.Scale(-1.0);
ScalarRes.Acc(1.0, Scalar.Current);
// ScalarMean
// ==========
ScalarMean.Clear();
ScalarMean.AccLaidBack(1.0, Scalar.Current);
// Thermodynamic pressure - only for Low-Mach number flows
// =======================================================
switch (SolverConf.PhysicsMode)
{
case PhysicsMode.LowMach:
LowMachSIMPLEControl lowMachConf = SolverConf as LowMachSIMPLEControl;
if (lowMachConf.ThermodynamicPressureMode == ThermodynamicPressureMode.MassDetermined)
{
ThermodynamicPressure.Clear();
ThermodynamicPressure.AccConstant(((MaterialLawLowMach)EoS).GetMassDeterminedThermodynamicPressure(lowMachConf.InitialMass.Value, Scalar.Current));
}
break;
case PhysicsMode.Multiphase:
break;
default:
throw new ApplicationException();
}
if (UpdateRhoVisc)
{
// Density
// =======
Rho.Clear();
Rho.ProjectFunction(1.0, EoS.GetDensity, null, Scalar.Current);
RhoMatrix.Update();
// Viscosity
// =========
Eta.Clear();
Eta.ProjectFunction(1.0, EoS.GetViscosity, null, Scalar.Current);
}
}
}
/// <summary>
/// [LowMach] Summand of all time steps for scalar variables, which are constant in space.
/// Used for time derivative of thermodynamic pressure in Low-Mach flows.
/// </summary>
/// <param name="dt"></param>
/// <param name="BDFOrder"></param>
/// <param name="Scalar"></param>
/// <returns>
/// Summand of all time steps of <paramref name="Scalar"/>.
/// </returns>
//public double ComputeSummandScalarHistory(double dt, int BDFOrder, ScalarFieldHistory<SinglePhaseField> Scalar) {
// double Summand = 0.0;
// for (int alpha = 0; alpha <= BDFOrder; alpha++)
// Summand += beta[BDFOrder - 1][alpha] * Scalar[1 - alpha].GetMeanValue(0);
// Summand *= 1.0 / (gamma[BDFOrder - 1] * dt);
// return Summand;
//}
/// <summary>
/// [LowMach] Summand of all time steps for density.
/// Used for time derivative of density in Corrector for Low-Mach flows.
/// </summary>
/// <param name="dt"></param>
/// <param name="BDFOrder"></param>
/// <param name="Temperature"></param>
/// <param name="EoS"></param>
/// <param name="RhsSummand"></param>
public void ComputeDensitySummand(double dt, int BDFOrder,
ScalarFieldHistory <SinglePhaseField> Temperature, MaterialLaw EoS,
SinglePhaseField RhsSummand)
{
for (int alpha = 0; alpha <= BDFOrder; alpha++)
{
RhsSummand.ProjectFunction(beta[BDFOrder - 1][alpha],
(X, U, cell) => EoS.GetDensity(U[0]),
null,
Temperature[1 - alpha]);
}
RhsSummand.Scale(1.0 / (gamma[BDFOrder - 1] * dt));
}
/// <summary>
/// [LowMach] Summand for previous time steps in momentum equation.
/// </summary>
/// <param name="dt"></param>
/// <param name="BDFOrder"></param>
/// <param name="Scalar"></param>
/// <param name="Velocity"></param>
/// <param name="SpatialComponent">Velocity component.</param>
/// <param name="EoS"></param>
/// <param name="RhsSummand">Accumulator for the result.</param>
public void ComputeRhsSummand(double dt, int BDFOrder,
ScalarFieldHistory <SinglePhaseField> Scalar, VectorFieldHistory <SinglePhaseField> Velocity, int SpatialComponent, MaterialLaw EoS,
SinglePhaseField RhsSummand)
{
for (int alpha = 1; alpha <= BDFOrder; alpha++)
{
RhsSummand.ProjectFunction(beta[BDFOrder - 1][alpha],
(X, U, cell) => EoS.GetDensity(U[0]) * U[1],
null,
Scalar[1 - alpha],
Velocity[1 - alpha][SpatialComponent]);
}
RhsSummand.Scale(1.0 / (gamma[BDFOrder - 1] * dt));
}
public NusseltFlux2D(MaterialLaw EoS)
{
this.EoS = EoS;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="Basis"></param>s
/// <param name="GridDat"></param>
/// <param name="EoS"></param>
/// <param name="Scalar"></param>
public QuadratureMatrix_Rho(Basis Basis, IGridData GridDat, MaterialLaw EoS, params SinglePhaseField[] Scalar)
: base(Basis, GridDat, Scalar)
{
this.EoS = EoS;
}
/// <summary>
/// ctor; parameter documentation see <see cref="swipViscosityBase.swipViscosityBase"/>.
/// </summary>
public swipViscosity_Term1_variante(double _penalty, MultidimensionalArray PenaltyLengthScales, int iComp, int D, IncompressibleBoundaryCondMap bcmap, ViscosityImplementation implMode,
ViscosityOption _ViscosityMode, double constantViscosityValue = double.NaN, double reynolds = double.NaN, MaterialLaw EoS = null,
Func <double, int, int, MultidimensionalArray, double> ComputePenalty = null)
: base(_penalty, PenaltyLengthScales, iComp, D, bcmap, implMode, _ViscosityMode, constantViscosityValue, reynolds, EoS, ComputePenalty)
{
}
