/// <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; parameter documentation see <see cref="swipViscosityBase.swipViscosityBase"/>. /// </summary> public swipViscosity_Term2(double _penalty, int iComp, int D, IncompressibleBoundaryCondMap bcmap, ViscosityOption _ViscosityMode, ViscositySolverMode ViscSolverMode = ViscositySolverMode.FullyCoupled, double constantViscosityValue = double.NaN, double reynolds = double.NaN, MaterialLaw EoS = null) : base(_penalty, iComp, D, bcmap, _ViscosityMode, constantViscosityValue, reynolds, EoS) { this.ViscSolverMode = ViscSolverMode; }
/// <summary> /// Ctor. /// </summary> /// <param name="Reynolds"></param> /// <param name="Schmidt"></param> /// <param name="EoS">Material law</param> /// <param name="PenaltyBase">C.f. Calculation of SIP penalty base, cf. Chapter 3 in /// K. Hillewaert, “Development of the discontinuous Galerkin method for high-resolution, large scale CFD and acoustics in industrial geometries”, /// Université catholique de Louvain, 2013.</param> /// <param name="BcMap">Boundary condition map</param> /// <param name="Mode">Equation type. Can be Temperature or MassFraction</param> /// <param name="Argument">The argument of the flux. Must be compatible with the DiffusionMode.</param> /// <param name="PenaltyLengthScales"></param> public SIPDiffusion(double Reynolds, double Schmidt, MaterialLaw EoS, double PenaltyBase, MultidimensionalArray PenaltyLengthScales, IncompressibleBoundaryCondMap BcMap, DiffusionMode Mode, string Argument) { this.m_Reynolds = Reynolds; this.m_Schmidt = Schmidt; this.EoS = EoS; this.PenaltyBase = PenaltyBase; this.BcMap = BcMap; this.ArgumentFunction = BcMap.bndFunction[Argument]; this.Mode = Mode; this.Argument = Argument; this.cj = PenaltyLengthScales; switch (BcMap.PhysMode) { case PhysicsMode.LowMach: this.m_ParameterOrdering = new string[] { VariableNames.Temperature0 }; break; case PhysicsMode.Combustion: this.m_ParameterOrdering = new string[] { VariableNames.Temperature0, VariableNames.MassFraction0_0, VariableNames.MassFraction1_0, VariableNames.MassFraction2_0, VariableNames.MassFraction3_0 }; break; default: throw new ApplicationException("Wrong physicsMode"); } }
/// <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_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> /// Cartesian grid, nothing fancy. /// </summary> public void CreateGrid(Context _Context, out GridCommons grd, out IncompressibleBoundaryCondMap bcMap) { grd = new Cartesian2DGrid(_Context.CommMaster, Grid1D.Linspace(-2, 2, 10), Grid1D.Linspace(-2, 2, 10)); grd.EdgeTagsNames.Add(1, "Pressure_Outlet"); grd.DefineEdgeTags(x => 1); bcMap = null; }
/// <summary> /// Ctor. /// </summary> /// <param name="Reynolds"></param> /// <param name="Prandtl"></param> /// <param name="EoS"></param> /// <param name="PenaltyBase"></param> /// <param name="BcMap"></param> public swipHeatConduction(double Reynolds, double Prandtl, MaterialLaw EoS, double PenaltyBase, IncompressibleBoundaryCondMap BcMap) { this.Reynolds = Reynolds; this.Prandtl = Prandtl; this.EoS = EoS; this.PenaltyBase = PenaltyBase; this.BcMap = BcMap; this.TemperatureFunction = BcMap.bndFunction[VariableNames.Temperature]; }
/// <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. /// </summary> /// <param name="Reynolds"></param> /// <param name="Schmidt"></param> /// <param name="EoS">Material law</param> /// <param name="PenaltyBase">C.f. Calculation of SIP penalty base, cf. Chapter 3 in /// K. Hillewaert, “Development of the discontinuous Galerkin method for high-resolution, large scale CFD and acoustics in industrial geometries”, /// Université catholique de Louvain, 2013.</param> /// <param name="BcMap">Boundary condition map</param> /// <param name="Mode">Equation type. Can be Temperature or MassFraction</param> /// <param name="Argument">The argument of the flux. Must be compatible with the DiffusionMode.</param> /// <param name="PenaltyLengthScales"></param> public SIPDiffusion(double Reynolds, double Schmidt, MaterialLaw EoS, double PenaltyBase, MultidimensionalArray PenaltyLengthScales, IncompressibleBoundaryCondMap BcMap, DiffusionMode Mode, string Argument) { this.Reynolds = Reynolds; this.Schmidt = Schmidt; this.EoS = EoS; this.PenaltyBase = PenaltyBase; this.BcMap = BcMap; this.ArgumentFunction = BcMap.bndFunction[Argument]; this.Mode = Mode; this.Argument = Argument; this.cj = PenaltyLengthScales; }
/// <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 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. /// </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 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(); } }
/// <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> /// ctor; parameter documentation see <see cref="swipViscosityBase.swipViscosityBase"/>. /// </summary> public swipViscosity_Term1(double _penalty, 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) : base(_penalty, iComp, D, bcmap, _ViscosityMode, constantViscosityValue, reynolds, EoS) { }
/// <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 /// </summary> /// <param name="_d"> /// spatial direction of derivative /// </param> /// <param name="bcmap"></param> public PressureGradientLin_d(int _d, IncompressibleBoundaryCondMap bcmap) { m_d = _d; m_bcmap = bcmap; pressureFunction = bcmap.bndFunction[VariableNames.Pressure]; }
/// <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)]; }
/// <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> public IP1_Flux_PressureCorrection(double penalty_base, MultidimensionalArray PenaltyLengthScales, IncompressibleBoundaryCondMap _BcMap) : base(penalty_base, PenaltyLengthScales, VariableNames.PresCor) { m_BcMap = _BcMap; }
/// <summary> /// ctor; parameter documentation see <see cref="swipViscosityBase.swipViscosityBase"/>. /// </summary> public swipViscosity_Term3(double _penalty, MultidimensionalArray PenaltyLengthScales, int iComp, int D, IncompressibleBoundaryCondMap bcmap, ViscosityImplementation implMode, ViscosityOption _ViscosityMode, ViscositySolverMode ViscSolverMode = ViscositySolverMode.FullyCoupled, double constantViscosityValue = double.NaN, double reynolds = double.NaN, MaterialLaw EoS = null) : base(_penalty, PenaltyLengthScales, iComp, D, bcmap, implMode, _ViscosityMode, constantViscosityValue, reynolds, EoS) { this.ViscSolverMode = ViscSolverMode; }