Esempio n. 1
0
        /// <summary>
        /// Checks if any field contains NaN's or Inf's and throws an exception if this is the case.
        /// </summary>
        public bool CheckForNanOrInf(SIMPLEControl SolverConf)
        {
            bool FoundNanOrInf = false;

            switch (SolverConf.PhysicsMode)
            {
            case PhysicsMode.Incompressible:
                if (WorkingSetFlowField.CheckForNanOrInf())
                {
                    FoundNanOrInf = true;
                }
                break;

            case PhysicsMode.LowMach:
                if (WorkingSetFlowField.CheckForNanOrInf() || WorkingSetVariableDensity.CheckForNanOrInf() || WorkingSetLowMach.CheckForNanOrInf())
                {
                    FoundNanOrInf = true;
                }
                break;

            case PhysicsMode.Multiphase:
                if (WorkingSetFlowField.CheckForNanOrInf() || WorkingSetVariableDensity.CheckForNanOrInf() || WorkingSetMultiphase.CheckForNanOrInf())
                {
                    FoundNanOrInf = true;
                }
                break;

            default:
                throw new NotImplementedException();
            }

            return(FoundNanOrInf);
        }
Esempio n. 2
0
            /// <summary>
            /// Ctor.
            /// </summary>
            /// <param name="GridDat"></param>
            /// <param name="Control"></param>
            /// <param name="IOFields"></param>
            /// <param name="RegisteredFields"></param>
            public VariableSetMultiphase(IGridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
                : base(GridDat, Control, IOFields, RegisteredFields)
            {
                // Auxiliary field to calculate Lambda in Convective : LinearFlux
                Basis MeanBasis = new Basis(GridDat, 0);

                PhiMean = new SinglePhaseField(MeanBasis, "PhiMean");
            }
Esempio n. 3
0
 /// <summary>
 /// Ctor.
 /// </summary>
 public MatrixAssemblyApproxInv(SIMPLEControl SolverConf, int LocalNoOfCells, SIMPLEMatrixAssembly Approx, int MaxUseMatrix = 1)
     : base(Approx.IsConstant, false, MaxUsePerIterMatrix: MaxUseMatrix)
 {
     m_Approx         = Approx;
     m_SolverConf     = SolverConf;
     m_LocalNoOfCells = LocalNoOfCells;
     base.Initialize();
 }
Esempio n. 4
0
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="GridDat"></param>
        /// <param name="Control"></param>
        /// <param name="IOFields"></param>
        /// <param name="RegisteredFields"></param>
        public VariableSet(IGridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
        {
            this.GridDat          = GridDat;
            this.Control          = Control;
            this.IOFields         = IOFields;
            this.RegisteredFields = RegisteredFields;

            WorkingSetFlowField = new VariableSetFlowField(GridDat, Control, IOFields, RegisteredFields);
        }
Esempio n. 5
0
            /// <summary>
            /// Ctor
            /// </summary>
            /// <param name="GridDat"></param>
            /// <param name="Control"></param>
            /// <param name="IOFields"></param>
            /// <param name="RegisteredFields"></param>
            public VariableSetLowMach(IGridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
                : base(GridDat, Control, IOFields, RegisteredFields)
            {
                // Auxiliary field to calculate Lambda in Convective : LinearFlux
                Basis MeanBasis = new Basis(GridDat, 0);

                TemperatureMean = new SinglePhaseField(MeanBasis, "TemperatureMean");

                // Thermodynamic pressure - the correct value will be calculated in VariableSet.Initialize()
                if (ThermodynamicPressure.Current.Basis.Degree != 0)
                {
                    throw new ApplicationException("The degree for ThermodynamicPressure in control-file has to be set to zero, since the ThermodynamicPressure is constant in space.");
                }
            }
Esempio n. 6
0
            /// <summary>
            /// Ctor.
            /// </summary>
            /// <param name="GridDat"></param>
            /// <param name="Control"></param>
            /// <param name="IOFields"></param>
            /// <param name="RegisteredFields"></param>
            /// <param name="SolverConf"></param>
            public VariableSetFlowField(IGridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
                : base(GridDat, Control, IOFields, RegisteredFields)
            {
                // Auxiliary field to calculate Lambda in Convective : LinearFlux
                Basis MeanBasis = new Basis(GridDat, 0);

                SinglePhaseField[] _VelocityMean = new SinglePhaseField[GridDat.SpatialDimension];
                _VelocityMean[0] = new SinglePhaseField(MeanBasis, "VelocityX_Mean");
                _VelocityMean[1] = new SinglePhaseField(MeanBasis, "VelocityY_Mean");
                if (GridDat.SpatialDimension == 3)
                {
                    _VelocityMean[2] = new SinglePhaseField(MeanBasis, "VelocityZ_Mean");
                }
                VelocityMean = new VectorField <SinglePhaseField>(_VelocityMean);
            }
Esempio n. 7
0
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="SolverConf"></param>
        public SIMPLEStepStatus(SIMPLEControl SolverConf) : this()
        {
            switch (SolverConf.PhysicsMode)
            {
            case PhysicsMode.Incompressible:
            case PhysicsMode.Multiphase:
                this.Timestep = new TimestepNumber(0, 0);
                break;

            case PhysicsMode.LowMach:
                this.Timestep = new TimestepNumber(0, 1, 0);
                break;

            default:
                throw new NotImplementedException();
            }
        }
Esempio n. 8
0
        public SolverConfiguration(
            SIMPLEControl control, IGridData GridDat, VariableSet workingSet, int MPIRank)
        {
            this.SpatialDimension = GridDat.SpatialDimension;
            this.MPIRank          = MPIRank;
            this.Control          = control;
            this.BcMap            = new IncompressibleBoundaryCondMap(GridDat, Control.BoundaryValues, Control.PhysicsMode);

            CheckSetupPressure(SpatialDimension);
            if (Control.PressureReferencePoint != null)
            {
                UnsetteledCoordinateMapping MappingPressure = new UnsetteledCoordinateMapping(
                    new Basis(GridDat, workingSet.Pressure.Basis.Degree));

                PressureReferencePointIndex = BoSSS.Solution.NSECommon.SolverUtils.GetIndexOfPressureReferencePoint(Control.PressureReferencePoint, MappingPressure, 0);
                if (PressureReferencePointIndex < 0)
                {
                    throw new ApplicationException("Unknown error finding index for pressure reference point.");
                }
            }

            // SIP penalty for viscous part of momentum equation
            this.PenaltyViscMomentum = Control.ViscousPenaltyScaling;

            // SIP penalty for SIP pressure correction
            if ((Control.PredictorApproximation == PredictorApproximations.Identity_IP1))
            {
                this.PenaltyPressureCorrection = Control.PressureCorrectionPenaltyScaling * GetSIPPenaltyBase(workingSet.Pressure.Basis.Degree, GridDat);
            }
            else if (Control.PressureCorrectionPenaltyScaling != 1.0)
            {
                throw new NotSupportedException("Extended property 'penalty_PressureCorrection' is only available for Identity_IP option.");
            }

            if (control.PhysicsMode == PhysicsMode.LowMach)
            {
                LowMachSIMPLEControl lowMachControl = control as LowMachSIMPLEControl;
                this.PenaltyHeatConduction = lowMachControl.PenaltyHeatConductionScaling * GetSIPPenaltyBase(workingSet.Pressure.Basis.Degree, GridDat);
            }

            this.Velocity = workingSet.Velocity;

            dt = control.Endtime / control.NoOfTimesteps;
        }
Esempio n. 9
0
        /// <summary>
        /// Create extended variables for variable density flows.
        /// </summary>
        /// <param name="control"></param>
        public void CreateExtendedVariables(SIMPLEControl control)
        {
            switch (control.PhysicsMode)
            {
            case PhysicsMode.Incompressible:
                break;

            case PhysicsMode.LowMach:
                WorkingSetVariableDensity = new VariableSetVariableDensity(GridDat, Control, IOFields, RegisteredFields);
                WorkingSetLowMach         = new VariableSetLowMach(GridDat, Control, IOFields, RegisteredFields);
                break;

            case PhysicsMode.Multiphase:
                WorkingSetVariableDensity = new VariableSetVariableDensity(GridDat, Control, IOFields, RegisteredFields);
                WorkingSetMultiphase      = new VariableSetMultiphase(GridDat, Control, IOFields, RegisteredFields);
                break;

            default:
                throw new NotImplementedException();
            }
        }
Esempio n. 10
0
        /// <summary>
        /// Push WorkingSet to next time step.
        /// </summary>
        public void Push(SIMPLEControl SolverConf)
        {
            if (SolverConf.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
            {
                this.Velocity.Push();
                switch (SolverConf.PhysicsMode)
                {
                case PhysicsMode.Incompressible:
                    break;

                case PhysicsMode.LowMach:
                    this.Temperature.Push();
                    this.ThermodynamicPressure.Push();
                    break;

                case PhysicsMode.Multiphase:
                    this.Phi.Push();
                    break;

                default:
                    throw new NotImplementedException();
                }
            }
        }
Esempio n. 11
0
 /// <summary>
 /// Ctor.
 /// </summary>
 /// <param name="GridDat"></param>
 /// <param name="Control"></param>
 /// <param name="IOFields"></param>
 /// <param name="RegisteredFields"></param>
 public BaseVariableSet(GridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
 {
     InitFromAttributes.CreateFieldsAuto(this, GridDat, Control.FieldOptions, BoSSS.Foundation.XDG.XQuadFactoryHelper.MomentFittingVariants.Classic, IOFields, RegisteredFields);
 }
Esempio n. 12
0
        /// <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);
                }
            }
        }
Esempio n. 13
0
        /// <summary>
        /// Calculate Nusselt number for Low-Mach number flows.
        /// </summary>
        /// <param name="Timestep"></param>
        /// <param name="GridDat"></param>
        /// <param name="Temperature"></param>
        /// <param name="SolverConf"></param>
        void CalculateNusselt(TimestepNumber Timestep, IGridData GridDat, SinglePhaseField Temperature, SIMPLEControl SolverConf)
        {
            // Initialize calculation of Nusselt number.
            if (NusseltNum == null)
            {
                LowMachSIMPLEControl lowMachConf = SolverConf as LowMachSIMPLEControl;
                NusseltNum = new NusseltNumber(GridDat, Temperature, lowMachConf.EoS, lowMachConf.EdgeTagsNusselt);

                if ((base.MPIRank == 0) && (CurrentSessionInfo.ID != Guid.Empty))
                {
                    LogNusselt = base.DatabaseDriver.FsDriver.GetNewLog("Nusselt", CurrentSessionInfo.ID);
                    LogNusselt.Write("Timestep");
                    for (int bc = 0; bc < NusseltNum.Nusselt.Length; bc++)
                    {
                        LogNusselt.Write("\t" + lowMachConf.EdgeTagsNusselt[bc]);
                    }
                    LogNusselt.WriteLine();
                }
            }

            // Calculate Nusselt number
            NusseltNum.CalculateNusseltNumber();

            // Write result to text file
            if ((base.MPIRank == 0) && (LogNusselt != null))
            {
                LogNusselt.Write(Timestep.ToString());
                for (int bc = 0; bc < NusseltNum.Nusselt.Length; bc++)
                {
                    LogNusselt.Write("\t" + NusseltNum.Nusselt[bc].ToString("0.0000000000E+00", NumberFormatInfo.InvariantInfo));
                }
                LogNusselt.WriteLine();
                LogNusselt.Flush();
            }
        }
Esempio n. 14
0
        /// <summary>
        /// Initialize all variables, which are not
        /// initialized by the control-file.
        /// Has to be called after <see cref="Application.SetInitial()"/>
        /// </summary>
        public void Initialize(SIMPLEControl SolverConf)
        {
            // Set history length according to time order
            if (SolverConf.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
            {
                this.Velocity.IncreaseHistoryLength(SolverConf.TimeOrder);
            }

            this.VelocityMean.Clear();
            this.VelocityMean.AccLaidBack(1.0, this.Velocity.Current);

            switch (SolverConf.PhysicsMode)
            {
            case PhysicsMode.Incompressible:
                break;

            case PhysicsMode.LowMach: {
                LowMachSIMPLEControl lowMachConf = SolverConf as LowMachSIMPLEControl;

                // Set history length according to time order
                if (SolverConf.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
                {
                    this.Temperature.IncreaseHistoryLength(SolverConf.TimeOrder);
                }

                // Initialize TemperatureMean
                this.TemperatureMean.Clear();
                this.TemperatureMean.AccLaidBack(1.0, this.Temperature.Current);

                // Initialize ThermodynamicPressure
                this.ThermodynamicPressure.Current.Clear();
                switch (lowMachConf.ThermodynamicPressureMode)
                {
                case ThermodynamicPressureMode.Constant:
                    this.ThermodynamicPressure.Current.AccConstant(1.0);
                    break;

                case ThermodynamicPressureMode.MassDetermined:
                    if (SolverConf.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
                    {
                        this.ThermodynamicPressure.IncreaseHistoryLength(SolverConf.TimeOrder);
                    }
                    this.ThermodynamicPressure.Current.AccConstant(
                        lowMachConf.EoS.GetMassDeterminedThermodynamicPressure(
                            lowMachConf.InitialMass.Value, this.Temperature.Current));
                    break;

                default:
                    throw new NotImplementedException();
                }

                // Initialize EoS
                lowMachConf.EoS.Initialize(this.ThermodynamicPressure);

                // Initialize Density
                this.Rho.Clear();
                this.Rho.ProjectFunction(1.0, lowMachConf.EoS.GetDensity, null, this.Temperature.Current);

                // Initialize Viscosity
                this.Eta.Clear();
                this.Eta.ProjectFunction(1.0, lowMachConf.EoS.GetViscosity, null, this.Temperature.Current);
            }
            break;

            case PhysicsMode.Multiphase: {
                MultiphaseSIMPLEControl multiphaseConf = SolverConf as MultiphaseSIMPLEControl;

                // Set history length according to time order
                if (SolverConf.Algorithm == SolutionAlgorithms.Unsteady_SIMPLE)
                {
                    this.Phi.IncreaseHistoryLength(SolverConf.TimeOrder);
                }

                // Initialize PhiMean
                this.PhiMean.Clear();
                this.PhiMean.AccLaidBack(1.0, this.Phi.Current);

                // Initialize Density
                this.Rho.Clear();
                this.Rho.ProjectFunction(1.0, multiphaseConf.EoS.GetDensity, null, this.Phi.Current);

                // Initialize Viscosity
                this.Eta.Clear();
                this.Eta.ProjectFunction(1.0, multiphaseConf.EoS.GetViscosity, null, this.Phi.Current);
            }
            break;

            default:
                throw new NotImplementedException();
            }
        }
Esempio n. 15
0
 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="GridDat"></param>
 /// <param name="Control"></param>
 /// <param name="IOFields"></param>
 /// <param name="RegisteredFields"></param>
 public VariableSetVariableDensity(IGridData GridDat, SIMPLEControl Control, ICollection <DGField> IOFields, ICollection <DGField> RegisteredFields)
     : base(GridDat, Control, IOFields, RegisteredFields)
 {
 }