protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { // assemble system, create matrix // ------------------------------ var volQrSch = new CellQuadratureScheme(true, CellMask.GetFullMask(this.GridData)); var edgQrSch = new EdgeQuadratureScheme(true, EdgeMask.GetFullMask(this.GridData)); double D = this.GridData.SpatialDimension; double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D; double penalty_factor = base.Control.penalty_poisson; { // equation assembly // ----------------- tr.Info("creating sparse system..."); Console.WriteLine("creating sparse system for {0} DOF's ...", T.Mapping.Ntotal); Stopwatch stw = new Stopwatch(); stw.Start(); SpatialOperator LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T"); var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, this.GridData.Cells.cj, base.Control); LapaceIp.EquationComponents["T"].Add(flux); LapaceIp.Commit(); #if DEBUG var RefLaplaceMtx = new MsrMatrix(T.Mapping); #endif LaplaceMtx = new BlockMsrMatrix(T.Mapping); LaplaceAffine = new double[T.Mapping.LocalLength]; LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, LaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); #if DEBUG LaplaceAffine.ClearEntries(); LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, RefLaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); MsrMatrix ErrMtx = RefLaplaceMtx.CloneAs(); ErrMtx.Acc(-1.0, LaplaceMtx); double err = ErrMtx.InfNorm(); double infNrm = LaplaceMtx.InfNorm(); Console.WriteLine("Matrix comparison error: " + err + ", matrix norm is: " + infNrm); Assert.Less(err, infNrm * 1e-10, "MsrMatrix2 comparison failed."); #endif //int q = LaplaceMtx._GetTotalNoOfNonZeros(); //tr.Info("finished: Number of non-zeros: " + q); stw.Stop(); Console.WriteLine("done {0} sec.", stw.Elapsed.TotalSeconds); //double condNo = LaplaceMtx.condest(BatchmodeConnector.Flavor.Octave); //Console.WriteLine("condition number: {0:0.####E-00} ",condNo); } } }
/// <summary> /// Step 2 of 2 for dynamic load balancing: restore this objects /// status after the grid has been re-distributed. /// </summary> public void DataRestoreAfterBalancing(GridUpdateDataVaultBase L, IEnumerable <DGField> Fields, IEnumerable <DGField> IterationResiduals, LevelSetTracker LsTrk, AggregationGridData[] _MultigridSequence) // { if (LsTrk != null) { this.LsTrk = LsTrk; } else { CreateDummyTracker(Fields); } Parameters = this.Operator.InvokeParameterFactory(Fields); if (m_BDF_Timestepper != null) { m_BDF_Timestepper.DataRestoreAfterBalancing(L, Fields, IterationResiduals, LsTrk, _MultigridSequence); } else if (m_RK_Timestepper != null) { throw new NotImplementedException("Load balancing and adaptive mesh refinement are not supported for Runge-Kutta XDG timestepping."); } else { throw new NotImplementedException(); } }
/// <summary> /// Step 2 of 2 for dynamic load balancing: restore this objects /// status after the grid has been re-distributed. /// </summary> public override void DataBackupBeforeBalancing(GridUpdateDataVaultBase L) { Timestepping.DataBackupBeforeBalancing(L); CurrentStateVector = null; CurrentResidualVector = null; ClearOperator(); }
/// <summary> /// Includes assembly of the matrix. /// </summary> /// <param name="L"></param> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { // create operator // =============== { double D = this.GridData.SpatialDimension; double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D; double penalty_factor = base.Control.penalty_poisson; BoundaryCondMap<BoundaryType> PoissonBcMap = new BoundaryCondMap<BoundaryType>(this.GridData, this.Control.BoundaryValues, "T"); LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T"); var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, ((GridData)(this.GridData)).Cells.cj, PoissonBcMap); LapaceIp.EquationComponents["T"].Add(flux); LapaceIp.Commit(); } //double condNo = LaplaceMtx.condest(BatchmodeConnector.Flavor.Octave); //Console.WriteLine("condition number: {0:0.####E-00} ",condNo); } }
/// <summary> /// /// </summary> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (new FuncTrace()) { // Create SIMPLEStatus SIMPLEStatus = new SIMPLEStepStatus(Control); // Create SIMPLEStep switch (Control.PhysicsMode) { case PhysicsMode.Incompressible: SIMPLEStep = new SIMPLEStepIncompressible(SolverConf, WorkingSet); break; case PhysicsMode.LowMach: SIMPLEStep = new SIMPLEStepLowMach(SolverConf, WorkingSet, WorkingSetMatrices); break; case PhysicsMode.Multiphase: SIMPLEStep = new SIMPLEStepMultiphase(SolverConf, WorkingSet, WorkingSetMatrices); break; default: throw new NotImplementedException(); } } }
/// <summary> /// /// </summary> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { diffOp = new SpatialOperator(new string[] { "u" }, Solution.NSECommon.VariableNames.VelocityVector(this.GridData.SpatialDimension), new string[] { "codom1" }, QuadOrderFunc.Linear()); switch (this.GridData.SpatialDimension) { case 2: diffOp.EquationComponents["codom1"].Add(new ScalarTransportFlux()); break; case 3: diffOp.EquationComponents["codom1"].Add(new ScalarTransportFlux3D()); break; default: throw new NotImplementedException("spatial dim. not supported."); } diffOp.Commit(); Timestepper = new RungeKutta(RungeKuttaScheme.TVD3, diffOp, new CoordinateMapping(u), Velocity.Mapping); //Timestepper = new ROCK4(diffOp, u.CoordinateVector, Velocity.Mapping); }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { diffOp = new SpatialOperator( new string[] { "c" }, new string[] { "viscosity", "VelocityX", "VelocityY" }, new string[] { "codom1" }, QuadOrderFunc.Linear()); diffOp.EquationComponents["codom1"].Add(new ScalarTransportFlux2D(inflowDirichletValue)); diffOp.Commit(); CoordinateMapping coordMap; coordMap = new CoordinateMapping(viscosity, Velocity[0], Velocity[1]); // 3 sub-grids MultidimensionalArray metricOne = MultidimensionalArray.Create(numOfCellsX); MultidimensionalArray metricTwo = MultidimensionalArray.Create(numOfCellsX); // 3 cells //metricOne[0] = 2; //metricOne[1] = 1; //metricOne[2] = 0.5; //metricTwo[0] = 1; //metricTwo[1] = 0.5; //metricTwo[2] = 2; // 4 cells metricOne[0] = 2; metricOne[1] = 1; metricOne[2] = 0.5; metricOne[3] = 0.25; metricTwo[0] = 0.5; metricTwo[1] = 2; metricTwo[2] = 0.25; metricTwo[3] = 1; CustomTimestepConstraint = new SurrogateConstraint(GridData, dtFixed, dtFixed, double.MaxValue, endTime, metricOne, metricTwo); timeStepper = new AdamsBashforthLTS( diffOp, new CoordinateMapping(c), coordMap, order: ABOrder, numOfClusters: this.numOfSubgrids, timeStepConstraints: new List <TimeStepConstraint>() { CustomTimestepConstraint }, fluxCorrection: false, reclusteringInterval: 1); // Sub-grid visualization //AdamsBashforthLTS timeStepper2 = timeStepper as AdamsBashforthLTS; //timeStepper2.SubGridField.Identification = "clusterLTS"; //m_IOFields.Add(timeStepper2.SubGridField); //timeStepper = timeStepper2; }
//XdgBDFTimestepping AltTimeIntegration; protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { int quadorder = this.u.Basis.Degree * 2 + 1; Op = new XSpatialOperatorMk2(1, 0, 1, (A, B, C) => quadorder, LsTrk.SpeciesNames, "u", "c1"); var blkFlux = new DxFlux(this.LsTrk, alpha_A, alpha_B); Op.EquationComponents["c1"].Add(blkFlux); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, alpha_A, alpha_B)); // flux am lev-set 0 Op.LinearizationHint = LinearizationHint.AdHoc; Op.TemporalOperator = new ConstantXTemporalOperator(Op, 1.0); Op.Commit(); if (L == null) { /* * AltTimeIntegration = new XdgBDFTimestepping( * new DGField[] { u }, new DGField[0], new DGField[] { uResidual }, base.LsTrk, * true, * DelComputeOperatorMatrix, Op.TemporalOperator, DelUpdateLevelset, * 3, // BDF3 * //-1, // Crank-Nicolson * //0, // Explicit Euler * LevelSetHandling.LieSplitting, * MassMatrixShapeandDependence.IsTimeDependent, * SpatialOperatorType.LinearTimeDependent, * MultigridOperatorConfig, * this.MultigridSequence, * this.LsTrk.SpeciesIdS.ToArray(), * quadorder, * this.THRESHOLD, * true, * this.Control.NonLinearSolver, * this.Control.LinearSolver); */ TimeIntegration = new XdgTimestepping( Op, new DGField[] { u }, new DGField[] { uResidual }, TimeSteppingScheme.BDF3, this.DelUpdateLevelset, LevelSetHandling.LieSplitting, MultigridOperatorConfig, MultigridSequence, _AgglomerationThreshold: this.THRESHOLD, LinearSolver: this.Control.LinearSolver, NonLinearSolver: this.Control.NonLinearSolver); } else { Debug.Assert(object.ReferenceEquals(this.MultigridSequence[0].ParentGrid, this.GridData)); TimeIntegration.DataRestoreAfterBalancing(L, new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk, this.MultigridSequence); //AltTimeIntegration.DataRestoreAfterBalancing(L, new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk, this.MultigridSequence); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { if (L == null) { } else { //throw new NotImplementedException("todo"); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { Op = new XSpatialOperator(1, 0, 1, QuadOrderFunc.SumOfMaxDegrees(RoundUp: true), "u", "c1"); Op.EquationComponents["c1"].Add(new DxFlux()); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new LevSetFlx_phi0(this.LsTrk)); // flux am lev-set 0 Op.EquationComponents["c1"].Add(new LevSetFlx_phi1(this.LsTrk)); // flux am lev-set 1 Op.Commit(); }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { if (L == null) { } else { //throw new NotImplementedException("todo"); //PlotCurrentState(100, new TimestepNumber(100, 1), 2); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { SpatialOperator diffOp = new SpatialOperator(1, 0, 1, QuadOrderFunc.MaxDegTimesTwo(), "u", "codom1"); diffOp.EquationComponents["codom1"].Add(new ScalarTransportFlux()); diffOp.Commit(); CustomTimestepConstraint = new SurrogateConstraint(GridData, dt_input, dt_input, double.MaxValue, endTime); if (LTS) { AdamsBashforthLTS ltsTimeStepper = new AdamsBashforthLTS( diffOp, new CoordinateMapping(u), null, ABorder, numOfSubgrids, fluxCorrection: true, reclusteringInterval: 0, timeStepConstraints: new List <TimeStepConstraint>() { CustomTimestepConstraint }); timeStepper = ltsTimeStepper; } else if (ALTS) { AdamsBashforthLTS ltsTimeStepper = new AdamsBashforthLTS( diffOp, new CoordinateMapping(u), null, ABorder, numOfSubgrids, fluxCorrection: false, reclusteringInterval: 1, timeStepConstraints: new List <TimeStepConstraint>() { CustomTimestepConstraint }); timeStepper = ltsTimeStepper; } else { timeStepper = new AdamsBashforth(diffOp, new CoordinateMapping(u), null, ABorder); //timeStepper = new RungeKutta(RungeKutta.RungeKuttaScheme.Heun, diffOp, new CoordinateMapping(u),null); //timeStepper = RungeKutta.Factory(ABorder, diffOp, new CoordinateMapping(u)); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { m_quadOrder = u1.Basis.Degree * 2; Op = new XSpatialOperator(2, 0, 2, (A, B, c) => m_quadOrder, "u1", "u2", "c1", "c2"); Op.EquationComponents["c1"].Add(new DxFlux("u1", -3.0)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -3.0)); Op.EquationComponents["c2"].Add(new DxFlux("u1", +3.0)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u1", +3.0)); Op.EquationComponents["c2"].Add(new DxFlux("u2", 77.7)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", 77.7)); Op.Commit(); }
/// <summary> /// Step 1 of 2 for dynamic load balancing: creating a backup of this objects /// status in the load-balancing thing <paramref name="L"/> /// </summary> public void DataBackupBeforeBalancing(GridUpdateDataVaultBase L) { if (m_BDF_Timestepper != null) { m_BDF_Timestepper.DataBackupBeforeBalancing(L); } else if (m_RK_Timestepper != null) { throw new NotImplementedException("Load balancing and adaptive mesh refinement are not supported for Runge-Kutta XDG timestepping."); } else { throw new NotImplementedException(); } this.LsTrk = null; this.Parameters = null; }
/// <summary> /// /// </summary> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { if (L == null) { // +++++++++++++++++++++++++++++++++++++++++++++++++++ // Creation of time-integrator (initial, no balancing) // +++++++++++++++++++++++++++++++++++++++++++++++++++ InitSolver(); Timestepping.RegisterResidualLogger(new ResidualLogger(this.MPIRank, this.DatabaseDriver, new Guid())); } else { // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // restore BDF time-stepper after grid redistribution (dynamic load balancing) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Timestepping.DataRestoreAfterBalancing(L, CurrentState.Fields, CurrentResidual.Fields, base.LsTrk, base.MultigridSequence); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { int quadorder = this.u.Basis.Degree * 2 + 1; Op = new XSpatialOperator(1, 0, 1, (A, B, C) => quadorder, "u", "c1"); var blkFlux = new DxFlux(this.LsTrk, alpha_A, alpha_B); Op.EquationComponents["c1"].Add(blkFlux); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, alpha_A, alpha_B)); // flux am lev-set 0 Op.Commit(); if (L == null) { TimeIntegration = new XdgBDFTimestepping( new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk, true, DelComputeOperatorMatrix, null, DelUpdateLevelset, 3, // BDF3 //-1, // Crank-Nicolson //0, // Explicit Euler LevelSetHandling.LieSplitting, MassMatrixShapeandDependence.IsTimeDependent, SpatialOperatorType.LinearTimeDependent, MassScale, MultigridOperatorConfig, this.MultigridSequence, this.LsTrk.SpeciesIdS.ToArray(), quadorder, this.THRESHOLD, true, this.Control.NonLinearSolver, this.Control.LinearSolver); } else { Debug.Assert(object.ReferenceEquals(this.MultigridSequence[0].ParentGrid, this.GridData)); TimeIntegration.DataRestoreAfterBalancing(L, new DGField[] { u }, new DGField[] { uResidual }, base.LsTrk, this.MultigridSequence); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { Op = new XSpatialOperatorMk2(1, 0, 1, QuadOrderFunc: (int[] DomDegs, int[] ParamDegs, int[] CoDomDegs) => QuadOrder, __Species: new [] { "B" }, __varnames: new[] { "u", "c1" }); Op.EquationComponents["c1"].Add(new DxFlux()); // Flux in Bulk Phase; if (usePhi0) { Op.EquationComponents["c1"].Add(new LevSetFlx_phi0(this.LsTrk)); // flux am lev-set 0 } if (usePhi1) { Op.EquationComponents["c1"].Add(new LevSetFlx_phi1(this.LsTrk)); // flux am lev-set 1 } //Op.EquationComponents["c1"].Add(new DxBroken()); Op.Commit(); }
/// <summary> /// Includes assembly of the matrix. /// </summary> /// <param name="L"></param> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { // create operator // =============== { double D = this.GridData.SpatialDimension; double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D; double penalty_factor = base.Control.penalty_poisson; BoundaryCondMap <BoundaryType> PoissonBcMap = new BoundaryCondMap <BoundaryType>(this.GridData, this.Control.BoundaryValues, "T"); LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T"); MultidimensionalArray LengthScales; if (this.GridData is GridData) { LengthScales = ((GridData)GridData).Cells.cj; } else if (this.GridData is AggregationGridData) { LengthScales = ((AggregationGridData)GridData).AncestorGrid.Cells.cj; } else { throw new NotImplementedException(); } var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, LengthScales, PoissonBcMap); LapaceIp.EquationComponents["T"].Add(flux); LapaceIp.Commit(); } } }
/// <summary> /// Includes assembly of the matrix. /// </summary> /// <param name="L"></param> protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { // create operator // =============== SpatialOperator LapaceIp; { double D = this.GridData.SpatialDimension; double penalty_base = (T.Basis.Degree + 1) * (T.Basis.Degree + D) / D; double penalty_factor = base.Control.penalty_poisson; BoundaryCondMap <BoundaryType> PoissonBcMap = new BoundaryCondMap <BoundaryType>(this.GridData, this.Control.BoundaryValues, "T"); LapaceIp = new SpatialOperator(1, 1, QuadOrderFunc.SumOfMaxDegrees(), "T", "T"); var flux = new ipFlux(penalty_base * base.Control.penalty_poisson, this.GridData.Cells.cj, PoissonBcMap); LapaceIp.EquationComponents["T"].Add(flux); LapaceIp.Commit(); } // Create Matrices // =============== { // time measurement for matrix assembly Stopwatch stw = new Stopwatch(); stw.Start(); // console Console.WriteLine("creating sparse system for {0} DOF's ...", T.Mapping.Ntotal); // quadrature domain var volQrSch = new CellQuadratureScheme(true, CellMask.GetFullMask(this.GridData)); var edgQrSch = new EdgeQuadratureScheme(true, EdgeMask.GetFullMask(this.GridData)); #if DEBUG // in DEBUG mode, we compare 'MsrMatrix' (old, reference implementation) and 'BlockMsrMatrix' (new standard) var RefLaplaceMtx = new MsrMatrix(T.Mapping); #endif using (new BlockTrace("SipMatrixAssembly", tr)) { LaplaceMtx = new BlockMsrMatrix(T.Mapping); LaplaceAffine = new double[T.Mapping.LocalLength]; LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, LaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); } #if DEBUG LaplaceAffine.ClearEntries(); LapaceIp.ComputeMatrixEx(T.Mapping, null, T.Mapping, RefLaplaceMtx, LaplaceAffine, volQuadScheme: volQrSch, edgeQuadScheme: edgQrSch); MsrMatrix ErrMtx = RefLaplaceMtx.CloneAs(); ErrMtx.Acc(-1.0, LaplaceMtx); double err = ErrMtx.InfNorm(); double infNrm = LaplaceMtx.InfNorm(); Console.WriteLine("Matrix comparison error: " + err + ", matrix norm is: " + infNrm); Assert.Less(err, infNrm * 1e-10, "MsrMatrix2 comparison failed."); #endif stw.Stop(); Console.WriteLine("done {0} sec.", stw.Elapsed.TotalSeconds); } //double condNo = LaplaceMtx.condest(BatchmodeConnector.Flavor.Octave); //Console.WriteLine("condition number: {0:0.####E-00} ",condNo); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { // Boundary condition map Material material = this.Control.GetMaterial(); IBoundaryConditionMap boundaryMap = new XDGCompressibleBoundaryCondMap(this.GridData, this.Control, material, new string[] { "A", "B" }); // Operator string[] variables = new string[] { CompressibleVariables.Density, CompressibleVariables.Momentum.xComponent, CompressibleVariables.Momentum.yComponent, CompressibleVariables.Energy }; if (ArtificialViscosityField != null) { this.XSpatialOperator = new XSpatialOperatorMk2(variables, new string[] { ArtificialViscosityField.Identification }, variables, (int[] A, int[] B, int[] C) => NonlinearQuadratureDegree, LsTrk.SpeciesIdS.ToArray()); } else { this.XSpatialOperator = new XSpatialOperatorMk2(variables, null, variables, (int[] A, int[] B, int[] C) => NonlinearQuadratureDegree, LsTrk.SpeciesIdS.ToArray()); } // Bulk fluxes this.XSpatialOperator.EquationComponents[CompressibleVariables.Density].Add(new OptimizedHLLCDensityFlux(boundaryMap, material)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Momentum.xComponent].Add(new OptimizedHLLCMomentumFlux(boundaryMap, 0, material)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Momentum.yComponent].Add(new OptimizedHLLCMomentumFlux(boundaryMap, 1, material)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Energy].Add(new OptimizedHLLCEnergyFlux(boundaryMap, material)); // Interface fluxes this.XSpatialOperator.EquationComponents[CompressibleVariables.Density].Add(new OptimizedHLLCFlux_Interface(this.LevelSetTracker, boundaryMap, material, FluxVariables.Density)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Momentum.xComponent].Add(new OptimizedHLLCFlux_Interface(this.LevelSetTracker, boundaryMap, material, FluxVariables.Momentum, 0)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Momentum.yComponent].Add(new OptimizedHLLCFlux_Interface(this.LevelSetTracker, boundaryMap, material, FluxVariables.Momentum, 1)); this.XSpatialOperator.EquationComponents[CompressibleVariables.Energy].Add(new OptimizedHLLCFlux_Interface(this.LevelSetTracker, boundaryMap, material, FluxVariables.Energy)); // Artificial viscosity bulk fluxes if (this.ArtificialViscosityField != null) { GridData gridData = (GridData)this.GridData; this.XSpatialOperator.EquationComponents[CompressibleVariables.Density].Add( new OptimizedLaplacianArtificialViscosityFlux( gridData, CompressibleVariables.Density, penaltySafetyFactor: 1.0, penaltyFactor: (Density.Basis.Degree + 1) * (Density.Basis.Degree + gridData.SpatialDimension) / gridData.SpatialDimension, cellLengthScales: gridData.Cells.CellLengthScale )); for (int d = 0; d < CompressibleEnvironment.NumberOfDimensions; d++) { this.XSpatialOperator.EquationComponents[CompressibleVariables.Momentum[d]].Add( new OptimizedLaplacianArtificialViscosityFlux( gridData, CompressibleVariables.Momentum[d], penaltySafetyFactor: 1.0, penaltyFactor: (Momentum[0].Basis.Degree + 1) * (Momentum[0].Basis.Degree + gridData.SpatialDimension) / gridData.SpatialDimension, cellLengthScales: gridData.Cells.CellLengthScale )); } this.XSpatialOperator.EquationComponents[CompressibleVariables.Energy].Add( new OptimizedLaplacianArtificialViscosityFlux( gridData, CompressibleVariables.Energy, penaltySafetyFactor: 1.0, penaltyFactor: (Energy.Basis.Degree + 1) * (Energy.Basis.Degree + gridData.SpatialDimension) / gridData.SpatialDimension, cellLengthScales: gridData.Cells.CellLengthScale )); } this.XSpatialOperator.Commit(); // Timestepper this.TimeStepper = new XDGShockTimeStepping( this.ConservativeFields, this.Residuals, this.LevelSetTracker, this.DelComputeOperatorMatrix, this.DelUpdateLevelset, RungeKuttaScheme.ExplicitEuler, LevelSetHandling.None, MassMatrixShapeandDependence.IsIdentity, SpatialOperatorType.Nonlinear, this.MassScale, this.MultigridOperatorConfig, base.MultigridSequence, this.LevelSetTracker.SpeciesIdS.ToArray(), this.NonlinearQuadratureDegree, this.Control.AgglomerationThreshold, true, this.Control.NonLinearSolver, this.Control.LinearSolver); }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { using (FuncTrace tr = new FuncTrace()) { this.BcMap = new IncompressibleBoundaryCondMap(this.GridData, grid.GetBoundaryConfig(), PhysicsMode.Incompressible); // assemble system, create matrix // ------------------------------ int D = GridData.SpatialDimension; //double penalty_base = ((double)((U[0].Basis.Degree + 1) * (U[0].Basis.Degree + D))) / ((double)D); double penalty_base = 1.0; double penalty_factor = 1.2; // equation assembly // ----------------- string[] CodNames = D.ForLoop(i => "C" + i); Operator = new SpatialOperator(VariableNames.VelocityVector(D), new string[] { VariableNames.ViscosityMolecular }, CodNames, QuadOrderFunc.Linear()); for (int d = 0; d < D; d++) { if ((this.whichTerms & Terms.T1) != 0) { var flx1 = new swipViscosity_Term1(penalty_base * penalty_factor, d, D, BcMap, ViscosityOption.VariableViscosity); flx1.g_Diri_Override = this.solution.U; flx1.g_Neu_Override = this.solution.dU; Operator.EquationComponents[CodNames[d]].Add(flx1); } if ((this.whichTerms & Terms.T2) != 0) { var flx2 = new swipViscosity_Term2(penalty_base * penalty_factor, d, D, BcMap, ViscosityOption.VariableViscosity); flx2.g_Diri_Override = this.solution.U; flx2.g_Neu_Override = this.solution.dU; Operator.EquationComponents[CodNames[d]].Add(flx2); } if ((this.whichTerms & Terms.T3) != 0) { var flx3 = new swipViscosity_Term3(penalty_base * penalty_factor, d, D, BcMap, ViscosityOption.VariableViscosity); flx3.g_Diri_Override = this.solution.U; flx3.g_Neu_Override = this.solution.dU; Operator.EquationComponents[CodNames[d]].Add(flx3); } } // */ Operator.Commit(); var map = this.U.Mapping; OperatorMtx = new MsrMatrix(map, map); Operator.ComputeMatrixEx(map, new DGField[] { this.mu }, map, OperatorMtx, this.bnd.CoordinateVector, volQuadScheme: null, edgeQuadScheme: null); // test for matrix symmetry // ======================== if (base.MPISize == 1) { double MatrixAssymmetry = OperatorMtx.SymmetryDeviation(); Console.WriteLine("Matrix asymmetry: " + MatrixAssymmetry); Assert.LessOrEqual(Math.Abs(MatrixAssymmetry), 1.0e-10); } } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { if (Operator != null) { return; } // create operator // --------------- Func <double[], double, double> S; switch (this.Control.InterfaceMode) { case InterfaceMode.MovingInterface: S = this.Control.S; break; case InterfaceMode.Splitting: S = (X, t) => 0.0; break; default: throw new NotImplementedException(); } int quadOrder; if (this.Control.Eq == Equation.ScalarTransport) { quadOrder = this.LinearQuadratureDegree; Func <double[], double, double>[] uBnd = new Func <double[], double, double> [this.Grid.EdgeTagNames.Keys.Max() + 1]; for (int iEdgeTag = 1; iEdgeTag < uBnd.Length; iEdgeTag++) { string nameEdgeTag; if (this.Grid.EdgeTagNames.TryGetValue((byte)iEdgeTag, out nameEdgeTag)) { if (!this.Control.BoundaryValues[nameEdgeTag].Evaluators.TryGetValue("u", out uBnd[iEdgeTag])) { uBnd[iEdgeTag] = (X, t) => 0.0; } } } Operator = new XSpatialOperator(1, 2, 1, (A, B, C) => quadOrder, "u", "Vx", "Vy", "Cod1"); Operator.EquationComponents["Cod1"].Add(new TranportFlux_Bulk() { Inflow = uBnd }); Operator.EquationComponents["Cod1"].Add(new TransportFlux_Interface(this.LsTrk, S)); Operator.Commit(); } else if (this.Control.Eq == Equation.HeatEq) { quadOrder = this.LinearQuadratureDegree; Operator = new XSpatialOperator(1, 0, 1, (A, B, C) => quadOrder, "u", "Cod1"); var bulkFlx = new HeatFlux_Bulk() { m_muA = this.Control.muA, m_muB = this.Control.muB, m_rhsA = this.Control.rhsA, m_rhsB = this.Control.rhsB }; var intfFlx = new HeatFlux_Interface(this.LsTrk, S) { m_muA = this.Control.muA, m_muB = this.Control.muB }; Operator.EquationComponents["Cod1"].Add(bulkFlx); Operator.EquationComponents["Cod1"].Add(intfFlx); Operator.Commit(); } else if (this.Control.Eq == Equation.Burgers) { quadOrder = this.NonlinearQuadratureDegree; Operator = new XSpatialOperator(1, 1, 1, (A, B, C) => quadOrder, "u", "u0", "Cod1"); Operator.EquationComponents["Cod1"].Add(new BurgersFlux_Bulk() { Direction = this.Control.BurgersDirection, Inflow = this.Control.u_Ex }); Operator.EquationComponents["Cod1"].Add(new BurgersFlux_Interface(this.LsTrk, S, this.Control.BurgersDirection)); Operator.Commit(); } else { throw new NotImplementedException(); } // create timestepper // ------------------ LevelSetHandling lsh; switch (this.Control.InterfaceMode) { case InterfaceMode.MovingInterface: lsh = LevelSetHandling.Coupled_Once; break; case InterfaceMode.Splitting: lsh = LevelSetHandling.LieSplitting; break; default: throw new NotImplementedException(); } RungeKuttaScheme rksch = null; int bdfOrder = -1000; if (this.Control.TimeSteppingScheme == TimeSteppingScheme.CrankNicolson) { bdfOrder = -1; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.ExplicitEuler) { bdfOrder = 0; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.ImplicitEuler) { bdfOrder = 1; } else if (this.Control.TimeSteppingScheme.ToString().StartsWith("BDF")) { bdfOrder = Convert.ToInt32(this.Control.TimeSteppingScheme.ToString().Substring(3)); } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK1) { rksch = RungeKuttaScheme.ExplicitEuler; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK1u1) { rksch = RungeKuttaScheme.ExplicitEuler2; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK2) { rksch = RungeKuttaScheme.Heun2; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK3) { rksch = RungeKuttaScheme.TVD3; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK4) { rksch = RungeKuttaScheme.RungeKutta1901; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK_ImplicitEuler) { rksch = RungeKuttaScheme.ImplicitEuler; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK_CrankNic) { rksch = RungeKuttaScheme.CrankNicolson; } else if (this.Control.TimeSteppingScheme == TimeSteppingScheme.RK_IMEX3) { rksch = RungeKuttaScheme.IMEX3; } else { throw new NotImplementedException(); } if (bdfOrder > -1000) { m_BDF_Timestepper = new XdgBDFTimestepping(new DGField[] { this.u }, new DGField[] { this.Residual }, LsTrk, true, DelComputeOperatorMatrix, DelUpdateLevelset, bdfOrder, lsh, MassMatrixShapeandDependence.IsTimeDependent, SpatialOperatorType.LinearTimeDependent, MassScale, null, base.MultigridSequence, this.LsTrk.SpeciesIdS.ToArray(), quadOrder, this.Control.AgglomerationThreshold, false); } else { m_RK_Timestepper = new XdgRKTimestepping(new DGField[] { this.u }, new DGField[] { this.Residual }, LsTrk, DelComputeOperatorMatrix, DelUpdateLevelset, rksch, lsh, MassMatrixShapeandDependence.IsTimeDependent, SpatialOperatorType.LinearTimeDependent, MassScale, null, base.MultigridSequence, this.LsTrk.SpeciesIdS.ToArray(), quadOrder, this.Control.AgglomerationThreshold, false); } }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { m_quadOrder = u1.Basis.Degree * 2; Setup(); //XLaplaceBCs xLaplaceBCs = new XLaplaceBCs(); //xLaplaceBCs.g_Diri = ((CommonParamsBnd inp) => 0.0); //xLaplaceBCs.IsDirichlet = (inp => true); //double penalty_base = (m_DGorder + 1) * (m_DGorder + 2) / 2; //var lengthScales = ((BoSSS.Foundation.Grid.Classic.GridData)GridData).Cells.PenaltyLengthScales; //var lap = new XLaplace_Bulk(this.LsTrk, 2.0 * penalty_base, "u1", xLaplaceBCs, 1.0, 1, 1000, lengthScales, XLaplace_Interface.Mode.SIP); Op = new XSpatialOperatorMk2(2, 0, 2, (A, B, c) => m_quadOrder, LsTrk.SpeciesNames, "u1", "u2", "c1", "c2"); //Op = new XSpatialOperatorMk2(1, 0, 1, (A, B, c) => m_quadOrder, LsTrk.SpeciesIdS.ToArray(), "u1","c1"); switch (m_Mshape) { case MatrixShape.laplace: var lengthScales = ((BoSSS.Foundation.Grid.Classic.GridData)GridData).Cells.PenaltyLengthScales; int p = u1.Basis.Degree; int D = this.GridData.SpatialDimension; double penalty_base = (p + 1) * (p + D) / D; double MU_A = 1; double MU_B = 10; Op.EquationComponents["c1"].Add(new XLaplace_Bulk(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u1", lengthScales)); // Bulk form Op.EquationComponents["c1"].Add(new XLaplace_Interface(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u1", lengthScales)); // coupling form Op.EquationComponents["c1"].Add(new XLaplace_Bulk(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u2", lengthScales)); // Bulk form Op.EquationComponents["c1"].Add(new XLaplace_Interface(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u2", lengthScales)); // coupling form Op.EquationComponents["c2"].Add(new XLaplace_Bulk(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u1", lengthScales)); // Bulk form Op.EquationComponents["c2"].Add(new XLaplace_Interface(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u1", lengthScales)); // coupling form Op.EquationComponents["c2"].Add(new XLaplace_Bulk(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u2", lengthScales)); // Bulk form Op.EquationComponents["c2"].Add(new XLaplace_Interface(this.LsTrk, MU_A, MU_B, penalty_base * 2, "u2", lengthScales)); // coupling form Op.EquationComponents["c1"].Add(new SourceTest("u1", 11)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new SourceTest("u2", 11)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u1", 11)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", 11)); // Flux in Bulk Phase; break; case MatrixShape.full: //tested: shape valid for testing Op.EquationComponents["c1"].Add(new DxFlux("u1", 3)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new DxFlux("u2", 4)); // Flux in Bulk Phase; break; case MatrixShape.full_var: //tested: shape valid for testing Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new SourceTest("u2", 2)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new DxFlux("u1", 3)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new DxFlux("u2", 4)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u1", -5)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", -6)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new DxFlux("u1", -7)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new DxFlux("u2", -8)); // Flux in Bulk Phase; break; case MatrixShape.full_spec: //tested: no spec coupling in the secondary diagonals (obviously) Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -1)); Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new DxFlux("u1", 10)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", -4)); Op.EquationComponents["c2"].Add(new SourceTest("u2", -2)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new DxFlux("u2", -11)); // Flux in Bulk Phase; break; case MatrixShape.full_var_spec: //tested: no spec coupling in the secondary diagonals (obviously) Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -1)); Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u2", -1)); Op.EquationComponents["c1"].Add(new DxFlux("u1", 3)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new DxFlux("u2", 4)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u1", -1)); Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", -1)); Op.EquationComponents["c2"].Add(new DxFlux("u1", 3)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new DxFlux("u2", 4)); // Flux in Bulk Phase; break; case MatrixShape.diagonal_var_spec: // block diagonal matrix (ignore cell coupling) Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u1", -2)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new SourceTest("u2", 3)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", -4)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -2)); Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", -4)); break; case MatrixShape.diagonal_spec: // block diagonal matrix (ignore cell and variable coupling) Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -2)); Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", -4)); Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", -4)); // Flux in Bulk Phase; break; case MatrixShape.diagonal: // sparse matrix (ignore cell and variable coupling) Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", -4)); // Flux in Bulk Phase; break; case MatrixShape.diagonal_var: // sparse matrix (ignore cell and variable coupling) Op.EquationComponents["c1"].Add(new SourceTest("u1", 1)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u1", -2)); // Flux in Bulk Phase; Op.EquationComponents["c1"].Add(new SourceTest("u2", 3)); // Flux in Bulk Phase; Op.EquationComponents["c2"].Add(new SourceTest("u2", -4)); // Flux in Bulk Phase; break; } //Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -1)); //Op.EquationComponents["c1"].Add(new DxFlux("u2", -1)); // Flux in Bulk Phase; //Op.EquationComponents["c2"].Add(new DxFlux("u1", 2)); // Flux in Bulk Phase; //Op.EquationComponents["c2"].Add(new DxFlux("u2", -2)); // Flux in Bulk Phase; //Op.EquationComponents["c1"].Add(new DxFlux("u1", -3.0)); // Flux in Bulk Phase; //Op.EquationComponents["c1"].Add(new LevSetFlx(this.LsTrk, "u1", -3.0)); //Op.EquationComponents["c2"].Add(new DxFlux("u1", +3.0)); // Flux in Bulk Phase; //Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u1", +3.0)); //Op.EquationComponents["c2"].Add(new DxFlux("u2", 77.7)); // Flux in Bulk Phase; //Op.EquationComponents["c2"].Add(new LevSetFlx(this.LsTrk, "u2", 77.7)); Op.Commit(); Basis maxB = map.BasisS.ElementAtMax(bss => bss.Degree); //massFact = new MassMatrixFactory(maxB, agg); massFact = LsTrk.GetXDGSpaceMetrics(this.LsTrk.SpeciesIdS.ToArray(), m_quadOrder).MassMatrixFactory; }
public override void DataBackupBeforeBalancing(GridUpdateDataVaultBase L) { TimeIntegration.DataBackupBeforeBalancing(L); }
protected override void CreateEquationsAndSolvers(GridUpdateDataVaultBase L) { AssembleMatrix(this.Control.MU_A, this.Control.MU_B, out Op_Matrix, out Op_Affine, out Op_Agglomeration, out Op_mass); Console.WriteLine("Matrix norm: {0}", Op_Matrix.InfNorm()); Console.WriteLine("Symm. diff: {0}", Op_Matrix.SymmetryDeviation()); }