/// <summary> /// Creates an array with an tanh spaced distribution of the mean /// values between maximum and minimum value of a given cell metric, /// e.g., minimal distance between two nodes in a cell <see cref="GridData.CellData.h_min"/> /// </summary> /// <param name="cellMetric">Given cell metric</param> /// <returns>Double[] with the length of the number of given sub-grids></returns> private MultidimensionalArray CreateInitialMeans(MultidimensionalArray cellMetric, int numOfClusters) { System.Diagnostics.Debug.Assert( cellMetric.Storage.All(d => double.IsNaN(d) == false), "Cell metrics contains f****d up entries"); double h_min = cellMetric.Min(); double h_max = cellMetric.Max(); //Console.WriteLine("Clustering: Create tanh spaced means"); // Getting global h_min and h_max ilPSP.MPICollectiveWatchDog.Watch(); h_min = h_min.MPIMin(); h_max = h_max.MPIMax(); if (h_min == h_max) { h_max += 0.1 * h_max; // Dirty hack for IBM cases with equidistant grids } // Tanh Spacing, which yields to more cell cluster for smaller cells var means = Grid1D.TanhSpacing(h_min, h_max, numOfClusters, 4.0, true).Reverse().ToArray(); // Equidistant spacing, in general not the best choice //means = GenericBlas.Linspace(h_min, h_max, NumOfSgrd).Reverse().ToArray(); return(MultidimensionalArray.CreateWrapper(means, numOfClusters)); }
/// <summary> /// Test using subsonicInlet at the inlet and /// supersonicInlet (Dirichlet) at the outlet /// </summary> /// <returns></returns> public static CNSControl[] EulerSubsonicInlet1D() { CNSControl[] templates = GetTemplates(); foreach (CNSControl c in templates) { int divisions = (int)c.Paramstudy_CaseIdentification.Single(t => t.Item1 == "divisions").Item2; int noOfCells = (2 << divisions) * 8; c.GridFunc = delegate { GridCommons grid = Grid1D.LineGrid( GenericBlas.Linspace(0.0, Math.PI / 2.0 + 0.0, noOfCells + 1)); grid.EdgeTagNames.Add(1, "supersonicInlet"); grid.EdgeTagNames.Add(2, "subsonicInlet"); grid.DefineEdgeTags((Vector x) => Math.Abs(x[0]) < 1e-14 ? (byte)2 : (byte)1); return(grid); }; c.ProjectName += "_subsonicInlet2"; c.AddBoundaryValue("subsonicInlet", CompressibleVariables.Density, exactDensity); c.AddBoundaryValue("subsonicInlet", CNSVariables.Velocity[0], exactVelocity); c.AddBoundaryValue("supersonicInlet", CompressibleVariables.Density, exactDensity); c.AddBoundaryValue("supersonicInlet", CNSVariables.Velocity[0], exactVelocity); c.AddBoundaryValue("supersonicInlet", CNSVariables.Pressure, exactPressure); } return(templates); }
/// <summary> /// Исследование характеристик работы решателя одномерных задач /// </summary> private static void SolverTask1DTests() { // Задаём дифференциальный оператор var op = new DerivativeOperator1D3P(); op.Kim1 = -1m / (2m * 0.5m); op.Ki = 2m; op.Kip1 = 1m / (2m * 0.5m); // Создаём одномерную расчетную область var raschOblast1D = new Grid1D(1.5m, 11, AxisEnum.X); // Создаём исследуемый объект var lineSegment = new GeometryPrimitive1DLineSegment(new Coordinate1D(0m), 0.5m); var raschObjectGeometry1D = new Geometry1D(); var geometryElement = new GeometryElement1D(new Coordinate1D(0.5m)); geometryElement.AddGeometryPrimitive(lineSegment); raschObjectGeometry1D.AddGeometryElement(geometryElement); var gridWithGeometryPrecalculated1D = new GridWithGeometryPreCalculated1D(raschOblast1D, raschObjectGeometry1D); var nodeSet1D = gridWithGeometryPrecalculated1D.NodeSet1D; // Создаём задачу var task = new SolverTask1D(); task.NodeSet1D = nodeSet1D; SolverResult result = Solver.Calculate(task); }
public void Init() { Func <double, double, double> rightPart = (r, t) => 0; Grid1D grid = Grid1D.Build(0, 1, 100); double[] ut0 = new double[grid.N]; for (int i = 0; i < grid.N; i++) { ut0[i] = 0; } TimeLimitCondition timeLimitCondition = new TimeLimitCondition(2 * Math.PI); var boundaryConditions = new[] { new BoundaryCondition(t => 0, BoundaryConditionLocation.Left, BoundaryConditionType.Dirichlet), new BoundaryCondition(t => Math.Cos(t), BoundaryConditionLocation.Right, BoundaryConditionType.Dirichlet) }; var scheme = new CrankNicolsonCylindricScheme1D(boundaryConditions, (r, t) => - (Math.Cos(t) / r) - r * Math.Sin(t), 1); var solution = scheme.Solve(timeLimitCondition, grid, ut0, 1E-3); Func <double, double, double> uExact = (r, t) => r * t; int n = 0; foreach (var layer in solution.Layers) { double[] g = new double[grid.N]; grid.CopyTo(g, 0); Shape2D shape = new Curve2D(g, layer); shape.Color = Color.Black; shape.Visible = true; shapes.Add(shape); } }
/// <summary> /// Test using SubsonicPressureInlet at the inlet and /// SubsonicOutlet at the outlet. That is, this test case /// uses physically correct boundary conditions /// </summary> /// <returns></returns> public static CNSControl[] EulerSubsonicPressureInletAndOutletTest1D() { CNSControl[] templates = GetTemplates(); foreach (CNSControl c in templates) { int divisions = (int)c.Paramstudy_CaseIdentification.Single(t => t.Item1 == "divisions").Item2; int noOfCells = (2 << divisions) * 8; c.GridFunc = delegate { GridCommons grid = Grid1D.LineGrid( GenericBlas.Linspace(0.0, Math.PI / 2.0 + 0.0, noOfCells + 1)); grid.EdgeTagNames.Add(1, "subsonicPressureInlet"); grid.EdgeTagNames.Add(2, "subsonicOutlet"); grid.DefineEdgeTags((Vector x) => Math.Abs(x[0]) < 1e-14 ? (byte)1 : (byte)2); return(grid); }; c.AddBoundaryValue("subsonicPressureInlet", "p0", totalPressure); c.AddBoundaryValue("subsonicPressureInlet", "T0", totalTemperature); c.AddBoundaryValue("subsonicOutlet", CNSVariables.Pressure, exactPressure); } return(templates); }
public V2DataOnGrid(string a, double b, Grid1D x, Grid1D y) : base(a, b) { Elem = new Grid1D[2]; Elem[0] = x; Elem[1] = y; }
/// <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; }
protected override void CreateOrLoadGrid() { Debug.Assert(Res % 2 == 0); double[] xNodes = Grid1D.Linspace(-1, 1, Res + 1); double[] yNodes = Grid1D.Linspace(-1, 1, Res + 1); GridCommons grd = new Cartesian2DGrid(m_Context.CommMaster, xNodes, yNodes, null, null, false, false); _Context.SetGrid(grd); }
static void Main(string[] args) { Grid1D temp1 = new Grid1D(0.5f, 5); Grid1D temp2 = new Grid1D(0.4f, 4); DateTime date1 = new DateTime(2020, 10, 21); V3DataOnGrid obj1 = new V3DataOnGrid("1111", date1, temp1, temp2); obj1.array = new double[2, 3]; obj1.InitRandom(4.5, 6.1); Console.WriteLine(obj1.ToLongString()); Console.WriteLine(); V3DataCollection obj2 = (V3DataCollection)obj1; Console.WriteLine(obj2.ToLongString()); Console.WriteLine(); V3MainCollection obj3 = new V3MainCollection(); obj3.AddDefaults(); Console.WriteLine(obj3.ToString()); int number = 1; Vector2 v = new Vector2(1, 2); foreach (V3Data data in obj3) { Console.WriteLine(); Console.WriteLine($"Nearest for an element №{number} in V3MainCollection"); Vector2[] res = data.Nearest(v); for (int i = 0; i < res.Length; i++) { Console.WriteLine(res[i]); } number++; } Console.ReadKey(); }
static void Main() { Grid1D G_1 = new Grid1D(3, 3); Grid1D G_2 = new Grid1D(5, 3); V2DataOnGrid V2_1 = new V2DataOnGrid("new_1", 5, G_1, G_2); V2_1.InitRandom(5, 10); //V2_1.NearAverage(0.9f); Console.WriteLine('\n' + V2_1.ToLongString()); V2DataCollection V2C = (V2DataOnGrid)V2_1; Console.WriteLine('\n' + V2C.ToLongString()); //V2C.NearAverage(0.9f); V2MainCollection VM_1 = new V2MainCollection(); VM_1.AddDefaults(); VM_1.ToString(); Vector2 vect = new Vector2((float)101010, (float)111); foreach (var item in VM_1) { item.NearAverage(0.5f); } //Console.WriteLine(V2C.ToLongString()); //Console.WriteLine(V2_1.NearAverage(0.5f)); //Console.WriteLine(V2_1.ToString()); //Console.WriteLine(V2_1.ToLongString()); V2DataCollection V2C_1 = new V2DataCollection("newC_1", 6); V2DataCollection V2C_2 = new V2DataCollection("newC_2", 7); //V2C_1.InitRandom(10,10,10,-20,30); //Console.WriteLine(V2C_1.ToLongString()); //V2C_1.NearAverage(0.9f); //Console.WriteLine(V2C_1.ToString()); //Console.WriteLine(V2C_1.ToLongString()); VM_1.Add(V2_1); VM_1.Add(V2C_1); VM_1.Add(V2C_2); //Console.WriteLine(VM_1.Count); VM_1.Remove("new_1", 5); //Console.WriteLine(VM_1.Count); //VM_1.AddDefaults(); //Console.WriteLine(VM_1.Count); }
void PlotCell0() { BoundingBox BB = new BoundingBox(2); GridDat.Cells.GetCellBoundingBox(0, BB); int Nx = 50; int Ny = 55; var xNodes = Grid1D.Linspace(BB.Min[0], BB.Max[0], Nx); var yNodes = Grid1D.Linspace(BB.Min[1], BB.Max[1], Ny); var GlobalNodes = MultidimensionalArray.Create(Nx, Ny, 2); for (int i = 0; i < Nx; i++) { for (int j = 0; j < Ny; j++) { GlobalNodes[i, j, 0] = xNodes[i]; GlobalNodes[i, j, 1] = yNodes[j]; } } var GlobalNodes_C = GlobalNodes.ResizeShallow(Nx * Ny, 2); var LocalNodes = MultidimensionalArray.Create(1, Nx * Ny, 2); GridDat.TransformGlobal2Local(GlobalNodes_C, LocalNodes, 0, 1, 0); var Values = MultidimensionalArray.Create(1, Nx, Ny); var Values_ = Values.ResizeShallow(1, Nx * Ny); var Gradients = MultidimensionalArray.Create(1, Nx, Ny, 2); var Gradients_ = Gradients.ResizeShallow(1, Nx * Ny, 2); var NodeSet = GridDat.NSC.CreateContainer(LocalNodes.ExtractSubArrayShallow(0, -1, -1), 0); var lh = GridDat.NSC.LockNodeSetFamily(NodeSet); f1.Evaluate(0, 1, 0, Values_); f1.EvaluateGradient(0, 1, 0, Gradients_); GridDat.NSC.UnlockNodeSetFamily(lh); xNodes.SaveToTextFile("C:\\tmp\\xNodes.txt"); yNodes.SaveToTextFile("C:\\tmp\\yNodes.txt"); FullMatrix output1 = new FullMatrix(Values.ExtractSubArrayShallow(0, -1, -1)); output1.ToTxtFile("C:\\tmp\\f.txt"); FullMatrix output2 = new FullMatrix(Gradients.ExtractSubArrayShallow(0, -1, -1, 0)); output2.ToTxtFile("C:\\tmp\\df.txt"); }
protected void Page_Load(object sender, EventArgs e) { labelDateTime.Text = System.DateTime.Now.ToString(); var price = 1234567.32m; labelMoney.Text = price.ToString("C", CultureInfo.CurrentCulture); var cultures = CultureInfo.GetCultures(CultureTypes.AllCultures) .Except(CultureInfo.GetCultures(CultureTypes.SpecificCultures)); Grid1D.DataSource = cultures; Grid1D.DataBind(); }
/// <summary> /// Creates Nodes, yes it really does! /// </summary> /// <param name="res"></param> /// <param name="stetch"> /// Factor which determines how much the intervals in the output grow; 1.0 is no stretching. /// </param> /// <param name="min"></param> /// <param name="max"></param> /// <returns></returns> static double[] CreateNodes(int res, double stetch, double min, double max) { if (stetch == 1.0) { return(GenericBlas.Linspace(min, max, res + 1)); } else { return(Grid1D.ExponentialSpaceing(min, max, res + 1, stetch)); // without proper preconditioning, } // a stretched grid is much more expensive than // an equidistant grid !!! }
/// <summary> /// creates a simple 2d/3d bilinear grid; /// </summary> protected override GridCommons CreateOrLoadGrid() { // 2d Grid // ======= var xNodes = Grid1D.Linspace(-1, 1, 3); var yNodes = Grid1D.Linspace(-1, 1, 3); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, CellType.Square_8, false, false); //var grd = Grid2D.BilinearSquareGrid(Grid1D.Linspace(-100, 100, 8), Grid1D.Linspace(-100, 100, 8), 0.8, 0, 0, null); //var grd = Grid2D.CurvedSquareGrid(Grid1D.Linspace(1, 2, 7), Grid1D.Linspace(0, 1, 16), 9); // var grd = Grid2D.CurvedSquareGrid(Grid1D.Linspace(1, 2, 3), Grid1D.Linspace(0, 1, 101), CellType.Square_9, true); //var grd = Grid3D.Cartesian3DGrid(Grid1D.Linspace(0, 1, 3), Grid1D.Linspace(0, 1, 3), Grid1D.Linspace(0, 1, 3),false, false, false,CellType.Cube_8); //var grd = Grid3D.Cartesian3DGrid(Grid1D.Linspace(-1, 1, 4), Grid1D.Linspace(-1, 1, 4), Grid1D.Linspace(-1, 1, 4),true, true, true, CellType.Cube_Linear); //var grd = Grid3D.CylinderGrid(Grid1D.Linspace(1, 2, 4), Grid1D.Linspace(0, 0.25, 4), Grid1D.Linspace(0, 2, 4), CellType.Cube_27, true, true); return(grd); }
public void AddDefaults() { Random rnd = new Random(); int n_new = rnd.Next(3, 5); for (int i = 0; i < n_new; i++) { Grid1D d1 = new Grid1D(3, 4); V2DataOnGrid New_Grid = new V2DataOnGrid("a", 4, d1, d1); V2DataCollection New_Coll = new V2DataCollection("b", 5); New_Grid.InitRandom(12, 20); New_Coll.InitRandom(5, 1, 10, 12, 20); Main_Data.Add(New_Grid); Main_Data.Add(New_Coll); } }
/// <summary> /// Initializes the Solver. Creates the objects that are used in the solver-method. /// Outlines the QuadNodesGlobal which are used as nodes for the geometric approach. /// Creates the edges on which the values will be defined in the solver-method. /// Creates a Cell which holds all the information of the parameters in the inside of the cell /// </summary> /// <param name="ExtPropertyBasis"></param> public ExtVelSolver_FastMarching(Basis ExtPropertyBasis) { this.SolverBasis = ExtPropertyBasis; this.GridDat = ExtPropertyBasis.GridDat; //Build Edges. double[] NodeGrid = Grid1D.Linspace(-1, 1, Math.Max(20, (this.SolverBasis.Degree + 1) * 2)); int maxNumberOfEdges = 4; edgesOfCell = new Edge[maxNumberOfEdges]; for (int i = 0; i < maxNumberOfEdges; i++) { edgesOfCell[i] = new Edge(NodeGrid, GridDat); } DaRuleS = this.GridDat.Grid.RefElements.Select(Kref => Kref.GetQuadratureRule(this.SolverBasis.Degree * 2)).ToArray(); QuadNodesGlobal = DaRuleS.Select(rule => MultidimensionalArray.Create(rule.NoOfNodes, GridDat.SpatialDimension)).ToArray(); }
/// <summary> /// Uses <see cref="SubsonicPressureInlet"/> at the inlet and /// <see cref="SupersonicInlet"/> (Dirichlet) at the outlet /// </summary> /// <returns></returns> public static CNSControl[] EulerSubsonicPressureInletTest1D() { CNSControl[] templates = GetTemplates(); foreach (CNSControl c in templates) { int divisions = (int)c.Paramstudy_CaseIdentification.Single(t => t.Item1 == "divisions").Item2; int noOfCells = (2 << divisions) * 8; c.GridFunc = delegate { GridCommons grid = Grid1D.LineGrid( GenericBlas.Linspace(0.0, Math.PI / 2.0 + 0.0, noOfCells + 1)); grid.EdgeTagNames.Add(1, "supersonicInlet"); grid.EdgeTagNames.Add(2, "subsonicPressureInlet"); grid.DefineEdgeTags(x => Math.Abs(x[0]) < 1e-14 ? (byte)2 : (byte)1); return(grid); }; } return(templates); }
/// <summary> /// Test using <see cref="SupersonicInlet"/> (Dirichlet) everywhere /// </summary> /// <returns></returns> public static CNSControl[] EulerSupersonicInlet1D() { CNSControl[] templates = GetTemplates(); foreach (CNSControl c in templates) { int divisions = (int)c.Paramstudy_CaseIdentification.Single(t => t.Item1 == "divisions").Item2; int noOfCells = (2 << divisions) * 8; c.GridFunc = delegate { GridCommons grid = Grid1D.LineGrid( GenericBlas.Linspace(0.0, Math.PI / 2.0 + 0.0, noOfCells + 1)); grid.EdgeTagNames.Add(1, "supersonicInlet"); grid.DefineEdgeTags(x => 1); return(grid); }; c.ProjectName += "_supersonicAll"; } return(templates.ToArray()); }
public void AddDefaults() { Random rnd = new Random(); Grid1D d1 = new Grid1D(1, 2); Grid1D d2 = new Grid1D(2, 2); V2DataOnGrid New_Grid = new V2DataOnGrid("A", 3, d1, d1); V2DataOnGrid New_Grid_1 = new V2DataOnGrid("A", 3, d2, d2); New_Grid.InitRandom(3, 7); New_Grid_1.InitRandom(4, 8); V2DataCollection New_Coll = new V2DataCollection("B", 5); New_Coll.InitRandom(4, 4, 6, 4, 6); Main_Data.Add(New_Grid); Main_Data.Add(New_Grid_1); Main_Data.Add(New_Grid_1); Main_Data.Add(New_Coll); }
private static CNSControl ShockTube_PartTest_Dynamic(int numOfCellsX, int numOfCellsY, int NoOfTimesteps, int NumberOfSubGrids, bool Repart, int RecInt) { CNSControl c = new CNSControl(); int dgDegree = 0; double sensorLimit = 1e-4; bool true1D = false; bool saveToDb = false; //string dbPath = @"D:\Weber\BoSSS\test_db"; string dbPath = null; c.DbPath = dbPath; c.savetodb = dbPath != null && saveToDb; c.GridPartType = GridPartType.Hilbert; bool AV = false; double xMin = 0; double xMax = 1; double yMin = 0; double yMax = 1; c.ExplicitScheme = ExplicitSchemes.LTS; c.ExplicitOrder = 1; c.NumberOfSubGrids = NumberOfSubGrids; c.ReclusteringInterval = RecInt; c.FluxCorrection = false; if (Repart) { // Add one balance constraint for each subgrid c.DynamicLoadBalancing_On = true; c.DynamicLoadBalancing_CellClassifier = new LTSCellClassifier(); c.DynamicLoadBalancing_CellCostEstimatorFactories.AddRange(LTSCellCostEstimator.Factory(c.NumberOfSubGrids)); c.DynamicLoadBalancing_ImbalanceThreshold = 0.0; c.DynamicLoadBalancing_Period = c.ReclusteringInterval; } c.GridFunc = delegate { double[] xNodes = GenericBlas.Linspace(xMin, xMax, numOfCellsX + 1); if (true1D) { var grid = Grid1D.LineGrid(xNodes, periodic: false); // Boundary conditions grid.EdgeTagNames.Add(1, "AdiabaticSlipWall"); grid.DefineEdgeTags(delegate(double[] _X) { return(1); }); return(grid); } else { double[] yNodes = GenericBlas.Linspace(yMin, yMax, numOfCellsY + 1); var grid = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: false, periodicY: false); // Boundary conditions grid.EdgeTagNames.Add(1, "AdiabaticSlipWall"); grid.DefineEdgeTags(delegate(double[] _X) { return(1); }); return(grid); } }; c.AddBoundaryValue("AdiabaticSlipWall"); // Initial conditions c.InitialValues_Evaluators.Add(CompressibleVariables.Density, delegate(double[] X) { double x = X[0]; if (true1D == false) { double y = X[1]; } if (x <= 0.5) { return(1.0); } else { return(0.125); } }); c.InitialValues_Evaluators.Add(CNSVariables.Pressure, delegate(double[] X) { double x = X[0]; if (true1D == false) { double y = X[1]; } if (x <= 0.5) { return(1.0); } else { return(0.1); } }); c.InitialValues_Evaluators.Add(CNSVariables.Velocity.xComponent, X => 0.0); if (true1D == false) { c.InitialValues_Evaluators.Add(CNSVariables.Velocity.yComponent, X => 0.0); } if (AV) { c.ActiveOperators = Operators.Convection | Operators.ArtificialViscosity; } else { c.ActiveOperators = Operators.Convection; } c.ConvectiveFluxType = ConvectiveFluxTypes.OptimizedHLLC; // Shock-capturing double epsilon0 = 1.0; double kappa = 0.5; if (AV) { Variable sensorVariable = CompressibleVariables.Density; c.CNSShockSensor = new PerssonSensor(sensorVariable, sensorLimit); c.ArtificialViscosityLaw = new SmoothedHeavisideArtificialViscosityLaw(c.CNSShockSensor, dgDegree, sensorLimit, epsilon0, kappa); } c.EquationOfState = IdealGas.Air; c.MachNumber = 1.0 / Math.Sqrt(c.EquationOfState.HeatCapacityRatio); c.ReynoldsNumber = 1.0; c.PrandtlNumber = 0.71; c.AddVariable(CompressibleVariables.Density, dgDegree); c.AddVariable(CompressibleVariables.Momentum.xComponent, dgDegree); c.AddVariable(CompressibleVariables.Energy, dgDegree); if (true1D == false) { c.AddVariable(CompressibleVariables.Momentum.yComponent, dgDegree); c.AddVariable(CNSVariables.Velocity.yComponent, dgDegree); if (AV) { c.AddVariable(CNSVariables.ArtificialViscosity, 2); } } else { if (AV) { c.AddVariable(CNSVariables.ArtificialViscosity, 1); } } c.AddVariable(CNSVariables.Velocity.xComponent, dgDegree); c.AddVariable(CNSVariables.Pressure, dgDegree); c.AddVariable(CNSVariables.Entropy, dgDegree); c.AddVariable(CNSVariables.LocalMachNumber, dgDegree); c.AddVariable(CNSVariables.Rank, 0); c.AddVariable(CNSVariables.CFL, 0); c.AddVariable(CNSVariables.CFLConvective, 0); if (AV) { c.AddVariable(CNSVariables.CFLArtificialViscosity, 0); } if (c.ExplicitScheme.Equals(ExplicitSchemes.LTS)) { c.AddVariable(CNSVariables.LTSClusters, 0); } // Time config c.dtMin = 0.0; c.dtMax = 1.0; c.CFLFraction = 0.3; c.Endtime = 0.25; //c.dtFixed = 1.5e-3; c.NoOfTimesteps = NoOfTimesteps; c.ProjectName = String.Format("Shock tube {0} Repartitioning", (Repart ? "with" : "without")); if (true1D) { c.SessionName = String.Format("{3}, 1D, dgDegree = {0}, noOfCellsX = {1}, sensorLimit = {2:0.00E-00}", dgDegree, numOfCellsX, sensorLimit, c.ProjectName); } else { c.SessionName = String.Format("{9}, 2D, dgDegree = {0}, noOfCellsX = {1}, noOfCellsX = {2}, sensorLimit = {3:0.00E-00}, CFLFraction = {4:0.00E-00}, ALTS {5}/{6}, GridPartType {7}, NoOfCores {8}", dgDegree, numOfCellsX, numOfCellsY, sensorLimit, c.CFLFraction, c.ExplicitOrder, c.NumberOfSubGrids, c.GridPartType, ilPSP.Environment.MPIEnv.MPI_Size, c.ProjectName); } return(c); }
public static IBM_Control IBMCylinderFlow(string _DbPath = null, int k = 2, bool xPeriodic = false, double VelXBase = 0.0) { IBM_Control C = new IBM_Control(); const double BaseSize = 1.0; // basic database options // ==================== C.savetodb = false; C.ProjectDescription = "Cylinder"; C.Tags.Add("with immersed boundary method"); // DG degrees // ========== C.FieldOptions.Add("VelocityX", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("VelocityY", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Pressure", new FieldOpts() { Degree = k - 1, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("PhiDG", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Phi", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); // grid and boundary conditions // ============================ C.GridFunc = delegate { var _xNodes1 = Grid1D.TanhSpacing(0, 1, 5, 1, false); _xNodes1 = _xNodes1.GetSubVector(0, (_xNodes1.Length - 1)); var _xNodes2 = GenericBlas.Linspace(1, 5.5, 35); _xNodes2 = _xNodes2.GetSubVector(0, (_xNodes2.Length - 1)); var _xNodes3 = Grid1D.TanhSpacing(5.5, 22, 20, 1.3, true); var xNodes = ArrayTools.Cat(_xNodes1, _xNodes2, _xNodes3); var _yNodes1 = Grid1D.TanhSpacing(0, 1, 5, 1.2, false); _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); var _yNodes2 = GenericBlas.Linspace(1, 3, 20); _yNodes2 = _yNodes2.GetSubVector(0, (_yNodes2.Length - 1)); var _yNodes3 = Grid1D.TanhSpacing(3, 4.1, 5, 1.2, true); var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2, _yNodes3); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: xPeriodic); grd.EdgeTagNames.Add(1, "Velocity_Inlet_upper"); grd.EdgeTagNames.Add(2, "Velocity_Inlet_lower"); if (!xPeriodic) { grd.EdgeTagNames.Add(3, "Velocity_Inlet_left"); grd.EdgeTagNames.Add(4, "Pressure_Outlet_right"); } grd.DefineEdgeTags(delegate(double[] X) { byte et = 0; if (Math.Abs(X[1] - (0 * BaseSize)) <= 1.0e-8) { et = 1; } if (Math.Abs(X[1] + (-4.1 * BaseSize)) <= 1.0e-8) { et = 2; } if (!xPeriodic && Math.Abs(X[0] - (0 * BaseSize)) <= 1.0e-8) { et = 3; } if (!xPeriodic && Math.Abs(X[0] + (-22 * BaseSize)) <= 1.0e-8) { et = 4; } Debug.Assert(et != 0); return(et); }); return(grd); }; C.AddBoundaryCondition("Velocity_Inlet_upper", "VelocityX", X => 0); C.AddBoundaryCondition("Velocity_Inlet_lower", "VelocityX", X => 0); if (!xPeriodic) { C.AddBoundaryCondition("Velocity_Inlet_left", "VelocityX", X => (4 * 1.5 * X[1] * (4.1 - X[1]) / (4.1 * 4.1))); } C.AddBoundaryCondition("Pressure_Outlet_right"); // Initial Values // ============== C.particleRadius = 0.5; C.InitialValues_Evaluators.Add("Phi", X => - (X[0] - 2).Pow2() + -(X[1] - 2).Pow2() + C.particleRadius.Pow2()); C.InitialValues_Evaluators.Add("VelocityX", X => 0); // Physical Parameters // =================== C.PhysicalParameters.mu_A = 0.05; C.PhysicalParameters.rho_A = 1; C.PhysicalParameters.IncludeConvection = true; C.PhysicalParameters.Material = true; // misc. solver options // ==================== C.AdvancedDiscretizationOptions.PenaltySafety = 1; C.AdvancedDiscretizationOptions.CellAgglomerationThreshold = 0.1; C.LevelSetSmoothing = false; C.MaxKrylovDim = 20; C.MaxSolverIterations = 100; C.VelocityBlockPrecondMode = MultigridOperator.Mode.SymPart_DiagBlockEquilib_DropIndefinite; C.NoOfMultigridLevels = 1; // Timestepping // ============ C.Timestepper_Scheme = IBM_Control.TimesteppingScheme.BDF2; double dt = 1E20; C.dtFixed = dt; C.dtMax = dt; C.dtMin = dt; C.Endtime = 200; C.NoOfTimesteps = 1; // haben fertig... // =============== return(C); }
/// <summary> /// See also <see cref="GRID_CASE"/> and <see cref="GRID_FILE"/>. /// </summary> protected override GridCommons CreateOrLoadGrid() { GridCommons grd; switch (GRID_CASE) { case 1: grd = Grid1D.LineGrid(GenericBlas.Linspace(-4, 4, 5)); break; case 2: { grd = Grid1D.LineGrid(GenericBlas.Linspace(-4, 4, 20)); break; } case 3: { double[] xnodes = new double[] { -2, 0, 2 }; double[] ynodes = new double[] { -2, 0, 2 }; double dx = xnodes[1] - xnodes[0]; double dy = ynodes[1] - ynodes[0]; //this.CellVolume = dx * dy; //if(Math.Abs(dx - dy) <= 1.0e-12) // EdgeArea = dx; grd = Grid2D.Cartesian2DGrid(xnodes, ynodes, periodicX: false, periodicY: false, type: CellType.Square_4); break; } case 4: { double[] xnodes = GenericBlas.Linspace(-1, 5, 9); double[] ynodes = GenericBlas.Linspace(-1, 5, 13); double dx = xnodes[1] - xnodes[0]; double dy = ynodes[1] - ynodes[0]; this.CellVolume = dx * dy; if (Math.Abs(dx - dy) <= 1.0e-12) { EdgeArea = dx; } grd = Grid2D.Cartesian2DGrid(xnodes, ynodes, periodicX: false, periodicY: false, type: CellType.Square_4); break; } case 5: { double[] xnodes = GenericBlas.Linspace(-1, 1, 8); double[] ynodes = GenericBlas.Linspace(-1, 1, 13); grd = Grid2D.UnstructuredTriangleGrid(xnodes, ynodes, JitterScale: 0.5); break; } case 6: { grd = Circle(); break; } case 7: { // test periodicity grd = Grid2D.CurvedSquareGrid(GenericBlas.Linspace(1, 2, 4), GenericBlas.Linspace(0, 0.25, 10), CellType.Square_9, PeriodicS: true); AltRefSol = true; break; } case 8: { double[] rNodes = GenericBlas.Linspace(1, 4, 8); double[] sNodes = GenericBlas.Linspace(0, 0.5, 15); grd = Grid2D.CurvedSquareGrid(rNodes, sNodes, CellType.Square_4, PeriodicS: false); break; } case 9: { double[] xNodes1 = GenericBlas.Linspace(-1, 0.3, 7); double[] yNodes1 = GenericBlas.Linspace(-1, 1, 13); double[] xNodes2 = GenericBlas.Linspace(0.3, 1, 5); double[] yNodes2 = GenericBlas.Linspace(-1, 1, 25); double[] xNodes3 = GenericBlas.Linspace(-1, 1, 8); double[] yNodes3 = GenericBlas.Linspace(-2, -1, 5); var grd1 = Grid2D.Cartesian2DGrid(xNodes1, yNodes1, type: CellType.Square_Linear); var grd2 = Grid2D.Cartesian2DGrid(xNodes2, yNodes2, type: CellType.Square_Linear); var grd3 = Grid2D.Cartesian2DGrid(xNodes3, yNodes3, type: CellType.Square_Linear); var grdJ = GridCommons.MergeLogically(grd1, GridCommons.MergeLogically(grd2, grd3)); grd = GridCommons.Seal(grdJ, 4); break; } case 10: { double[] xNodes1 = GenericBlas.Linspace(-1, 0.3, 4); double[] xNodes2 = GenericBlas.Linspace(0.3, 1, 5); double[] yNodes1 = GenericBlas.Linspace(-1, 1, 9); double[] yNodes2 = GenericBlas.Linspace(-1, 1, 5); double[] zNodes1 = GenericBlas.Linspace(-1, 1, 5); double[] zNodes2 = GenericBlas.Linspace(-1, 1, 3); var grd1 = Grid3D.Cartesian3DGrid(xNodes1, yNodes1, zNodes1); var grd2 = Grid3D.Cartesian3DGrid(xNodes2, yNodes2, zNodes2); var grdJ = GridCommons.MergeLogically(grd1, grd2); grd = GridCommons.Seal(grdJ, 4); break; } case 11: { grd = Grid2D.Trapezoidal2dGrid(4, 2, 2, GenericBlas.Linspace(0, 1, 2)); break; } case 12: { var grid1 = Grid2D.Cartesian2DGrid(GenericBlas.Linspace(-3, 5, 5), GenericBlas.Linspace(-1, 1, 2)); //grd = base_grid; //grid1.Plot2DGrid(); var gdat1 = new GridData(grid1); var grid2 = gdat1.Adapt(new int[] { 1, 2 }, null, out GridCorrelation o2c_1); //grid2.Plot2DGrid(); var gdat2 = new GridData(grid2); var grid3 = gdat2.Adapt(new int[] { 2, 4 }, null, out GridCorrelation o2c_2); //grid3.Plot2DGrid(); var gdat3 = new GridData(grid3); var grid4 = gdat3.Adapt(new int[] { 11, 14, 15 }, null, out GridCorrelation o2c_3); //grid4.Plot2DGrid(); var gdat4 = new GridData(grid4); var grid5 = gdat4.Adapt(new[] { 4, 21, 22, 10 }, new[] { new[] { 13, 14, 15, 16 } }, out GridCorrelation o2c_4); //grid5.Plot2DGrid(); grd = grid5; break; } case 13: { double[] rNodes = GenericBlas.Linspace(1, 4, 8); double[] sNodes = GenericBlas.Linspace(0, 0.5, 15); grd = Grid2D.CurvedSquareGrid(rNodes, sNodes, CellType.Square_9, PeriodicS: false); break; } case 14: { double[] rNodes = GenericBlas.Linspace(1, 4, 13); double[] sNodes = GenericBlas.Linspace(0, 0.5, 25); grd = Grid2D.CurvedSquareGrid(rNodes, sNodes, CellType.Square_16, PeriodicS: false); break; } case 15: { double[] rNodes = GenericBlas.Linspace(1, 2, 4); double[] sNodes = GenericBlas.Linspace(0, 0.5, 4); double[] zNodes = GenericBlas.Linspace(-1, 1, 5); grd = Grid3D.CylinderGrid(rNodes, sNodes, zNodes, CellType.Cube_27, PeriodicS: false, PeriodicZ: false); break; } case 16: { grd = Grid2D.Ogrid(0.5, 1, 5, 3, CellType.Square_4); break; } case 17: { grd = Grid3D.Ogrid(0.5, 1, 3, 3, GenericBlas.Linspace(0, 4, 3)); break; } case 18: { // aggregation grid double[] xNodes = GenericBlas.Linspace(-1, 1, 5); double[] yNodes = GenericBlas.Linspace(-1, 1, 5); var baseGrid = Grid2D.UnstructuredTriangleGrid(xNodes, yNodes); var baseGdat = new GridData(baseGrid); var aggGrid = CoarseningAlgorithms.Coarsen(baseGdat, 2); base.AggGrid = aggGrid; grd = null; double dx = xNodes[1] - xNodes[0]; double dy = yNodes[1] - yNodes[0]; this.CellVolume = dx * dy; if (Math.Abs(dx - dy) <= 1.0e-12) { EdgeArea = dx; } break; } // ++++++++++++++++++++++++++++++++++++++++++++++++++++ // more expensive grids (not tested in DEBUG MODE) // ++++++++++++++++++++++++++++++++++++++++++++++++++++ case 30: { double[] xnodes = GenericBlas.Linspace(-1, 1, 7); double[] ynodes = GenericBlas.Linspace(-1, 1, 9); double[] znodes = GenericBlas.Linspace(-1, 1, 8); grd = Grid3D.Cartesian3DGrid(xnodes, ynodes, znodes, periodicX: false, periodicY: false, periodicZ: false); break; } // +++++++++++++++++++++++++++++++++ // grids imported from GMSH/CGNS // +++++++++++++++++++++++++++++++++ case 50: { // gmsh grid import test Console.WriteLine("Loading file: '" + GRID_FILE + "'..."); grd = GridImporter.Import(GRID_FILE); //Console.WriteLine("done. " + grd.NoOfUpdateCells.MPISum() + " cells loaded."); //Plot2dGridGnuplot(grd); HashSet <CellType> cellTypes = new HashSet <CellType>(); foreach (var cell in grd.Cells) { if (!cellTypes.Contains(cell.Type)) { cellTypes.Add(cell.Type); } } Console.Write("Cell types: "); foreach (var ct in cellTypes) { Console.Write(ct); Console.Write(" "); } Console.WriteLine(); break; } default: throw new NotSupportedException(); } return(grd); }
static public IBM_Control IBMCylinderFlow(string _DbPath = null, int k = 2, bool only_channel = true, bool pardiso = true, int no_p = 1, int no_it = 1, bool load_Grid = false, string _GridGuid = null) { // int cells_x, int cells_yz IBM_Control C = new IBM_Control(); bool xPeriodic = false; int i = 2; const double BaseSize = 1.0; // basic database options // ====================== //C.DbPath = _DbPath; C.DbPath = @"\\dc1\userspace\stange\HiWi_database\PerformanceTests"; C.savetodb = true; bool restart = false; string restartSession = "67a29dcc-ade9-4704-b198-b3380e774f5a"; string restartGrid = "42e1ede0-40fc-4267-9d48-94c0397ac9a5"; bool startFromGivenGrid = true; string startGrid = "42e1ede0-40fc-4267-9d48-94c0397ac9a5"; switch (i) { case 1: C.MeshFactor = 1.258; // was 1.33 break; case 2: C.MeshFactor = 3.0; //1.77; //0.92; break; case 3: C.MeshFactor = 0.7; // was 07 break; default: throw new ApplicationException(); } if (pardiso) { if (only_channel) { C.SessionName = "2DChannel_Pardiso_k" + k + "_MeshFactor" + C.MeshFactor + "_no_p" + no_p + "_run" + no_it; } else { C.SessionName = "Cylinder_Pardiso_k" + k + "_MeshFactor" + C.MeshFactor + "_no_p" + no_p + "_run" + no_it; } } else { if (only_channel) { C.SessionName = "2DChannel_Mumps_k" + k + "_MeshFactor" + C.MeshFactor + "_no_p" + no_p + "_run" + no_it; } else { C.SessionName = "Cylinder_Mumps_k" + k + "_MeshFactor" + C.MeshFactor + "_no_p" + no_p + "_run" + no_it; } } C.saveperiod = 1; //C.SessionName = "Sphere_k" + k + "_h" + h+"Re100"; C.Tags.Add("Pardiso " + pardiso); C.Tags.Add("only channel " + only_channel); C.Tags.Add("k " + k); C.Tags.Add("no_p" + no_p); C.Tags.Add("run " + no_it); C.Tags.Add("MeshFactor " + C.MeshFactor); C.ProjectName = "FixedCylinderRe100_k" + i + "_CellAgglo02_penalty4_newMesh2"; C.ProjectDescription = "Cylinder"; // DG degrees // ========== C.FieldOptions.Add("VelocityX", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("VelocityY", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); //Console.WriteLine("Achtung: equal order!!!!"); C.FieldOptions.Add("Pressure", new FieldOpts() { Degree = k - 1, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("PhiDG", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Phi", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); // restart options // =============== if (restart) { C.RestartInfo = new Tuple <Guid, TimestepNumber>(new Guid(restartSession), -1); C.GridGuid = new Guid(restartGrid); } //grid and boundary conditions // ============================ // Initial Values // ============== double radius = 0.5; C.PhysicalParameters.rho_A = 1.0; C.PhysicalParameters.mu_A = 1.0 / 100.0; if (!restart) { if (!startFromGivenGrid) { C.GridFunc = delegate { var _xNodes1 = Grid1D.TanhSpacing(-2.0, -1.0, Convert.ToInt32(10.0 * C.MeshFactor), 0.5, false); //10 _xNodes1 = _xNodes1.GetSubVector(0, (_xNodes1.Length - 1)); var _xNodes2 = GenericBlas.Linspace(-1.0, 2.0, Convert.ToInt32(35.0 * C.MeshFactor)); //35 _xNodes2 = _xNodes2.GetSubVector(0, (_xNodes2.Length - 1)); var _xNodes3 = Grid1D.TanhSpacing(2.0, 20.0, Convert.ToInt32(60.0 * C.MeshFactor), 1.5, true); //60 var xNodes = ArrayTools.Cat(_xNodes1, _xNodes2, _xNodes3); var _yNodes1 = Grid1D.TanhSpacing(-2.0, -1.0, Convert.ToInt32(7.0 * C.MeshFactor), 0.9, false); //7 _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); var _yNodes2 = GenericBlas.Linspace(-1.0, 1.0, Convert.ToInt32(25.0 * C.MeshFactor)); //25 _yNodes2 = _yNodes2.GetSubVector(0, (_yNodes2.Length - 1)); var _yNodes3 = Grid1D.TanhSpacing(1.0, 2.1, Convert.ToInt32(7.0 * C.MeshFactor), 1.1, true); //7 var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2, _yNodes3); //double[] xNodes = GenericBlas.Linspace(0 * BaseSize, 22 * BaseSize, 25); //double[] yNodes = GenericBlas.Linspace(0 * BaseSize, 4.1 * BaseSize, 25); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: xPeriodic); grd.EdgeTagNames.Add(1, "Velocity_Inlet_upper"); grd.EdgeTagNames.Add(2, "Velocity_Inlet_lower"); if (!xPeriodic) { grd.EdgeTagNames.Add(3, "Velocity_Inlet_left"); grd.EdgeTagNames.Add(4, "Pressure_Outlet_right"); } grd.DefineEdgeTags(delegate(double[] X) { byte et = 0; if (Math.Abs(X[1] - (-2.0 * BaseSize)) <= 1.0e-8) { et = 1; } if (Math.Abs(X[1] - (+2.1 * BaseSize)) <= 1.0e-8) { et = 2; } if (!xPeriodic && Math.Abs(X[0] - (-2.0 * BaseSize)) <= 1.0e-8) { et = 3; } if (!xPeriodic && Math.Abs(X[0] - (+20.0 * BaseSize)) <= 1.0e-8) { et = 4; } Debug.Assert(et != 0); return(et); }); Console.WriteLine("Cells: {0}", grd.NumberOfCells); return(grd); }; } else { C.GridGuid = new Guid(startGrid); } if (only_channel) { C.InitialValues_Evaluators.Add("Phi", X => - 1); } else { C.InitialValues_Evaluators.Add("Phi", X => - (X[0]).Pow2() + -(X[1]).Pow2() + radius.Pow2()); } //C.InitialValues.Add("Phi", X => -1); C.InitialValues_Evaluators.Add("VelocityX", X => 4.0 * 1.5 * (X[1] + 2.0) * (4.1 - (X[1] + 2.0)) / (4.1 * 4.1)); } //C.GridFunc = delegate { // // Box1 // var box1_p1 = new double[2] { -2, -2 }; // var box1_p2 = new double[2] { 20, 2.1 }; // var box1 = new GridBox(box1_p1, box1_p2, 46, 20); //k1: 70,25 ; k2: 46,20 ; k3: 35,15 // // Box2 // var box2_p1 = new double[2] { -2, -2 }; // var box2_p2 = new double[2] { 3, 2.1 }; // var box2 = new GridBox(box2_p1, box2_p2, 26, 40); //k1: 40,50 ; k2: 26,40; k3: 20, 30 // // Box3 // var box3_p1 = new double[2] { -2, -1 }; // var box3_p2 = new double[2] { 1, 1 }; // var box3 = new GridBox(box3_p1, box3_p2, 32, 38); //k1: 48,58 ; k2: 32,38; k3: 24, 30 // // Box4 // var box4_p1 = new double[2] { -0.7, -0.72 }; // var box4_p2 = new double[2] { 0.7, 0.7 }; // var box4 = new GridBox(box4_p1, box4_p2, 30, 56); //k1: 44,84 ; k2: 30,56; k3: 22, 42 // var grd = Grid2D.HangingNodes2D(box1, box2, box3,box4); // grd.EdgeTagNames.Add(1, "Velocity_Inlet_upper"); // grd.EdgeTagNames.Add(2, "Velocity_Inlet_lower"); // if (!xPeriodic) { // grd.EdgeTagNames.Add(3, "Velocity_Inlet_left"); // grd.EdgeTagNames.Add(4, "Pressure_Outlet_right"); // } // grd.DefineEdgeTags(delegate (double[] X) { // byte et = 0; // if (Math.Abs(X[1] - (-2 * BaseSize)) <= 1.0e-8) // et = 1; // if (Math.Abs(X[1] - (+2.1 * BaseSize)) <= 1.0e-8) // et = 2; // if (!xPeriodic && Math.Abs(X[0] - (-2 * BaseSize)) <= 1.0e-8) // et = 3; // if (!xPeriodic && Math.Abs(X[0] - (+20.0 * BaseSize)) <= 1.0e-8) // et = 4; // Debug.Assert(et != 0); // return et; // }); // Console.WriteLine("Cells: {0}", grd.NumberOfCells); // return grd; //}; C.AddBoundaryCondition("Velocity_Inlet_upper", "VelocityX", X => 0.0); C.AddBoundaryCondition("Velocity_Inlet_lower", "VelocityX", X => 0.0); //-(4 * 1.5 * X[1] * (4.1 - X[1]) / (4.1 * 4.1)) if (!xPeriodic) { C.AddBoundaryCondition("Velocity_Inlet_left", "VelocityX", X => (4.0 * 1.5 * (X[1] + 2.0) * (4.1 - (X[1] + 2.0)) / (4.1 * 4.1))); //C.AddBoundaryCondition("Velocity_Inlet_left", "VelocityX#A", X => 1); } C.AddBoundaryCondition("Pressure_Outlet_right"); //C.InitialValues.Add("Phi", X => phi(X, 0)); //C.InitialValues.Add("Phi", X => ((X[0] / (radius * BaseSize)) - mPx) * (X[0] / (radius * BaseSize)) - mPx) + ((X[1]) / (radius * BaseSize)) - 2.)Pow2() - radius.Pow2())); // quadratic form // ); //C.InitialValues.Add("VelocityX", delegate (double[] X) //{ // double x = X[0]; // double y = X[1]; // double R = Math.Sqrt((x + 1).Pow2() + y.Pow2()); // double xVel = 0; // if (R < 0.75) // { // xVel = 1; // } // return xVel; //}); //C.InitialValues.Add("VelocityY", delegate (double[] X) { // double x = X[0]; // double y = X[1]; // double R = Math.Sqrt((x + 1).Pow2() + (y).Pow2()); // double yVel = 0; // if (R < 0.75) { // yVel = 1; // } // return yVel; //}); // For restart //C.RestartInfo = new Tuple<Guid, TimestepNumber>(new Guid("8f5cfed9-31c7-4be8-aa56-e92e5348e08b"), 95); //C.GridGuid = new Guid("71ffc0c4-66aa-4762-b07e-45385f34b03f"); // Physical Parameters // =================== C.PhysicalParameters.IncludeConvection = true; // misc. solver options // ==================== C.AdvancedDiscretizationOptions.CellAgglomerationThreshold = 0.2; C.AdvancedDiscretizationOptions.PenaltySafety = 4; C.LevelSetSmoothing = false; //C.option_solver = "direct"; C.MaxKrylovDim = 20; C.MaxSolverIterations = 50; C.VelocityBlockPrecondMode = MultigridOperator.Mode.SymPart_DiagBlockEquilib_DropIndefinite; //C.NoOfMultigridLevels = 0; if (pardiso) { C.whichSolver = DirectSolver._whichSolver.PARDISO; } else { C.whichSolver = DirectSolver._whichSolver.MUMPS; } // Timestepping // ============ C.Timestepper_Scheme = IBM_Control.TimesteppingScheme.BDF2; double dt = 0.1; C.dtMax = dt; C.dtMin = dt; C.Endtime = 70; C.NoOfTimesteps = 10; // haben fertig... // =============== return(C); }
public static IBMControl IBMNACA0012(int MeshPara, int dgDegree, double CFL, double agglomeration, double alpha) { IBMControl c = new IBMControl(); // Solver Settings c.dtMin = 0.0; c.dtMax = 1.0; c.Endtime = 1000.0; c.CFLFraction = CFL; c.NoOfTimesteps = 200000; c.PrintInterval = 10; //c.ResidualInterval = 100; //c.ResidualLoggerType = ResidualLoggerTypes.ChangeRate | ResidualLoggerTypes.Query; //c.ResidualBasedTerminationCriteria.Add("changeRate_L2_abs_rhoE", 1E-8); //IBM Settings c.LevelSetBoundaryTag = "AdiabaticSlipWall"; c.LevelSetQuadratureOrder = 2 * dgDegree + 2; c.AgglomerationThreshold = agglomeration; // NEXT STEP: SET THIS BOOL TO FALSE AND JUST USE IN POSITIVE SUB_VOLUME; // THEN TRY BOUNDING BOX APPROACH? // WHY THE HELL DOES THIS CONFIGURATION FAIL!??!?!?!? c.CutCellQuadratureType = XQuadFactoryHelper.MomentFittingVariants.Classic; c.SurfaceHMF_ProjectNodesToLevelSet = false; c.SurfaceHMF_RestrictNodes = true; c.SurfaceHMF_UseGaussNodes = false; c.VolumeHMF_NodeCountSafetyFactor = 3.0; c.VolumeHMF_RestrictNodes = true; c.VolumeHMF_UseGaussNodes = false; //Guid restart = new Guid("cd061fe3-3215-483a-8790-f6fd686d6676"); //c.RestartInfo = new Tuple<Guid, BoSSS.Foundation.IO.TimestepNumber>(restart, -1); // Session Settings //c.DbPath = @"\\fdyprime\userspace\kraemer-eis\FDY-Cluster\dbe_NACA\"; c.savetodb = false; c.saveperiod = 10000; c.ProjectName = "MeshPara:" + MeshPara + "_CFL=" + c.CFLFraction + "_p=" + dgDegree + "_agg=" + c.AgglomerationThreshold + "_alpha=" + alpha + "_HMF=" + c.CutCellQuadratureType; c.ProjectDescription = "NACA0012 Steady Test with Ma=0.5"; c.Tags.Add("NACA0012"); c.Tags.Add("IBM Test"); c.Tags.Add("steady"); // Solver Type c.DomainType = DomainTypes.StaticImmersedBoundary; c.ActiveOperators = Operators.Convection; c.ConvectiveFluxType = ConvectiveFluxTypes.OptimizedHLLC; // Time-Stepping Settings c.ExplicitScheme = ExplicitSchemes.RungeKutta; c.ExplicitOrder = 1; //Material Settings c.EquationOfState = IdealGas.Air; c.MachNumber = 1.0 / Math.Sqrt(c.EquationOfState.HeatCapacityRatio); // Primary CNSVariables c.AddVariable(CompressibleVariables.Density, dgDegree); c.AddVariable(CompressibleVariables.Momentum.xComponent, dgDegree); c.AddVariable(CompressibleVariables.Momentum.yComponent, dgDegree); c.AddVariable(CompressibleVariables.Energy, dgDegree); c.AddVariable(IBMVariables.LevelSet, 8); // Refined Region double xBegin = -0.012; double xEnd = 1.01; c.GridFunc = delegate { int chords = 100; int xleft = -chords; int xRight = chords; int yBottom = -chords; int yTop = chords; double spacingFactor = 3.95; double[] xnodes1 = Grid1D.TanhSpacing(xleft, xBegin, MeshPara + 1, spacingFactor, false); double[] xnodes2 = Grid1D.TanhSpacing_DoubleSided(xBegin, xEnd, MeshPara + 1, 2.0); double[] xnodes3 = Grid1D.TanhSpacing(xEnd, xRight, MeshPara + 1, spacingFactor, true); double[] xComplete = new double[xnodes1.Length + xnodes2.Length + xnodes3.Length - 2]; for (int i = 0; i < xnodes1.Length; i++) { xComplete[i] = xnodes1[i]; } for (int i = 1; i < xnodes2.Length; i++) { xComplete[i + xnodes1.Length - 1] = xnodes2[i]; } for (int i = 1; i < xnodes3.Length; i++) { xComplete[i + xnodes1.Length + xnodes2.Length - 2] = xnodes3[i]; } double yrefinedTop = 0.2; double yrefinedBottom = -0.2; double[] ynodes1 = Grid1D.TanhSpacing(yBottom, yrefinedBottom, MeshPara + 1, spacingFactor, false); double[] ynodes2 = GenericBlas.Linspace(yrefinedBottom, yrefinedTop, (int)(0.75 * MeshPara) + 1); double[] ynodes3 = Grid1D.TanhSpacing(yrefinedTop, yTop, MeshPara + 1, spacingFactor, true); double[] yComplete = new double[ynodes1.Length + ynodes2.Length + ynodes3.Length - 2]; for (int i = 0; i < ynodes1.Length; i++) { yComplete[i] = ynodes1[i]; } for (int i = 1; i < ynodes2.Length; i++) { yComplete[i + ynodes1.Length - 1] = ynodes2[i]; } for (int i = 1; i < ynodes3.Length; i++) { yComplete[i + ynodes1.Length + ynodes2.Length - 2] = ynodes3[i]; } int numOfCellsX = (xRight - xleft) * MeshPara; int numOfCellsY = (yTop - yBottom) * MeshPara; GridCommons grid = Grid2D.Cartesian2DGrid(xComplete, yComplete); grid.EdgeTagNames.Add(1, "supersonicinlet"); grid.EdgeTagNames.Add(2, "AdiabaticSlipWall"); grid.DefineEdgeTags((Vector X) => 1); grid.Name = "[" + xleft + "," + xRight + "]x[" + yBottom + "," + yTop + "]_Cells:(" + (xComplete.Length - 1) + "x" + (yComplete.Length - 1) + ")"; return(grid); }; // Functions Func <double[], double, double> rho = (X, t) => 1.0; Func <double[], double, double> u0 = (X, t) => 1.0; Func <double[], double, double> u1 = (X, t) => 0.0; Func <double[], double, double> pressure = (X, t) => 2.8571428571428; Func <double[], double> test = X => 1 - 0.05 * 0.4 / 1.4 * Math.Pow(Math.Exp(1 - X[0] * X[0] - X[1] * X[1]), (1 / 0.4)); Func <double[], double, double> levelSet = delegate(double[] X, double t) { double value = 0.0; double radian = alpha * Math.PI / 180; double xRotated = 1 + Math.Cos(radian) * (X[0] - 1) - Math.Sin(radian) * (X[1]); double yRotated = Math.Sin(radian) * (X[0] - 1) + Math.Cos(radian) * (X[1]); double a = 0.6; //double b = 0.2969; double c1 = 0.126; double d = 0.3516; double e = 0.2843; double f = 0.1036; if (yRotated >= 0.0 || (X[0] > 0.562875 && X[1] > 0)) { //if (yRotated >= 0.0 ){ value = Math.Pow((yRotated + a * (c1 * xRotated + d * Math.Pow(xRotated, 2) - e * Math.Pow(xRotated, 3) + f * Math.Pow(xRotated, 4))), 2) - 0.0317338596 * xRotated; } else { value = Math.Pow((-yRotated + a * (c1 * xRotated + d * Math.Pow(xRotated, 2) - e * Math.Pow(xRotated, 3) + f * Math.Pow(xRotated, 4))), 2) - 0.0317338596 * xRotated; } //value = yRotated - Math.Tan(radian)*xRotated; return(value); }; c.LevelSetFunction = levelSet; //Initial Values c.InitialValues_Evaluators.Add(CompressibleVariables.Density, X => rho(X, 0.0)); c.InitialValues_Evaluators.Add(CNSVariables.Velocity.xComponent, X => u0(X, 0.0)); c.InitialValues_Evaluators.Add(CNSVariables.Velocity.yComponent, X => u1(X, 0.0)); c.InitialValues_Evaluators.Add(CNSVariables.Pressure, X => pressure(X, 0.0)); //BoundaryConditions c.AddBoundaryValue("AdiabaticSlipWall"); c.AddBoundaryValue("supersonicInlet", CompressibleVariables.Density, rho); c.AddBoundaryValue("supersonicInlet", CNSVariables.Velocity.xComponent, u0); c.AddBoundaryValue("supersonicInlet", CNSVariables.Velocity.yComponent, u1); c.AddBoundaryValue("supersonicInlet", CNSVariables.Pressure, pressure); // Queries //c.Queries.Add("L2ErrorEntropy", IBMQueries.L2Error(state => state.Entropy, (X, t) => 2.8571428571428)); //c.Queries.Add("IBMDragForce", IBMQueries.IBMDragForce()); //c.Queries.Add("IBMLiftForce", IBMQueries.IBMLiftForce()); return(c); }
private static CNSControl ShockTubeToro1Template(int dgDegree, ExplicitSchemes explicitScheme, int explicitOrder, int noOfCells = 50, double gridStretching = 0.0, bool twoD = false) { double densityLeft = 1.0; double velocityLeft = 0.0; double pressureLeft = 1.0; double densityRight = 0.125; double velocityRight = 0.0; double pressureRight = 0.1; double discontinuityPosition = 0.5; CNSControl c = new CNSControl(); c.DbPath = null; //c.DbPath = @"c:\bosss_db\"; c.savetodb = false; c.ActiveOperators = Operators.Convection; c.ConvectiveFluxType = ConvectiveFluxTypes.OptimizedHLLC; c.EquationOfState = IdealGas.Air; c.MachNumber = 1.0 / Math.Sqrt(c.EquationOfState.HeatCapacityRatio); c.ReynoldsNumber = 1.0; c.PrandtlNumber = 0.71; c.ExplicitScheme = explicitScheme; c.ExplicitOrder = explicitOrder; c.AddVariable(CompressibleVariables.Density, dgDegree); c.AddVariable(CompressibleVariables.Momentum.xComponent, dgDegree); c.AddVariable(CompressibleVariables.Energy, dgDegree); c.AddVariable(CNSVariables.Velocity.xComponent, dgDegree); c.AddVariable(CNSVariables.Pressure, dgDegree); c.AddVariable(CNSVariables.Rank, 0); c.GridFunc = delegate { double xMin = 0.0; double xMax = 1.0; double yMin = 0.0; double yMax = 1.0; double[] xNodes; double[] yNodes; if (gridStretching > 0.0) { xNodes = Grid1D.TanhSpacing(xMin, xMax, noOfCells + 1, gridStretching, true); yNodes = Grid1D.TanhSpacing(yMin, yMax, 1 + 1, gridStretching, true); } else { xNodes = GenericBlas.Linspace(xMin, xMax, noOfCells + 1); yNodes = GenericBlas.Linspace(yMin, yMax, 1 + 1); } GridCommons grid; if (twoD) { grid = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: false, periodicY: false); } else { grid = Grid1D.LineGrid(xNodes, periodic: false); } // Boundary conditions grid.EdgeTagNames.Add(1, "AdiabaticSlipWall"); grid.DefineEdgeTags(delegate(double[] _X) { return(1); }); return(grid); }; c.AddBoundaryValue("AdiabaticSlipWall"); Material material = c.GetMaterial(); StateVector stateLeft = StateVector.FromPrimitiveQuantities( material, densityLeft, new Vector(velocityLeft, 0.0, 0.0), pressureLeft); StateVector stateRight = StateVector.FromPrimitiveQuantities( material, densityRight, new Vector(velocityRight, 0.0, 0.0), pressureRight); c.InitialValues_Evaluators.Add( CompressibleVariables.Density, X => stateLeft.Density + (stateRight.Density - stateLeft.Density) * (X[0] - discontinuityPosition).Heaviside()); c.InitialValues_Evaluators.Add( CNSVariables.Velocity.xComponent, X => stateLeft.Velocity.x + (stateRight.Velocity.x - stateLeft.Velocity.x) * (X[0] - discontinuityPosition).Heaviside()); c.InitialValues_Evaluators.Add( CNSVariables.Pressure, X => stateLeft.Pressure + (stateRight.Pressure - stateLeft.Pressure) * (X[0] - discontinuityPosition).Heaviside()); if (twoD) { c.InitialValues_Evaluators.Add(CNSVariables.Velocity.yComponent, X => 0); } if (!twoD) { var riemannSolver = new ExactRiemannSolver(stateLeft, stateRight, new Vector(1.0, 0.0, 0.0)); riemannSolver.GetStarRegionValues(out double pStar, out double uStar); c.Queries.Add("L2ErrorDensity", QueryLibrary.L2Error( CompressibleVariables.Density, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Density)); c.Queries.Add("L2ErrorVelocity", QueryLibrary.L2Error( CNSVariables.Velocity.xComponent, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Velocity.x)); c.Queries.Add("L2ErrorPressure", QueryLibrary.L2Error( CNSVariables.Pressure, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Pressure)); } c.dtMin = 0.0; c.dtMax = 1.0; //c.dtFixed = 1.0e-6; c.CFLFraction = 0.1; c.Endtime = 0.2; c.NoOfTimesteps = int.MaxValue; // Use METIS since ParMETIS is not installed on build server c.GridPartType = GridPartType.METIS; return(c); }
public static IBM_Control[] IBMCylinderFlow(string _DbPath = null, int k = 2, bool xPeriodic = false, double VelXBase = 0.0) { List <IBM_Control> R = new List <IBM_Control>(); foreach (int i in new int[] { 3 }) { IBM_Control C = new IBM_Control(); C.Paramstudy_CaseIdentification = new Tuple <string, object>[] { new Tuple <string, object>("k", i), }; k = i; const double BaseSize = 1.0; // basic database options // ====================== C.DbPath = @"\\fdyprime\userspace\krause\BoSSS_DBs\Paper_CellAgglo01_Penalty4"; C.savetodb = false; C.ProjectName = "FixedCylinderRe100_k" + i + "_CellAgglo02_penalty4_newMesh2"; switch (i) { case 1: C.MeshFactor = 1.33; // was 1.33 break; case 2: C.MeshFactor = 0.92; break; case 3: C.MeshFactor = 0.7; // was 07 break; default: throw new ApplicationException(); } C.ProjectDescription = "Cylinder"; C.Tags.Add("with immersed boundary method"); // DG degrees // ========== C.FieldOptions.Add("VelocityX", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("VelocityY", new FieldOpts() { Degree = k, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); //Console.WriteLine("Achtung: equal order!!!!"); C.FieldOptions.Add("Pressure", new FieldOpts() { Degree = k - 1, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("PhiDG", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Phi", new FieldOpts() { Degree = 2, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); //grid and boundary conditions // ============================ C.GridFunc = delegate { var _xNodes1 = Grid1D.TanhSpacing(-2, -1, Convert.ToInt32(10 * C.MeshFactor), 0.5, false); //10 _xNodes1 = _xNodes1.GetSubVector(0, (_xNodes1.Length - 1)); var _xNodes2 = GenericBlas.Linspace(-1, 2, Convert.ToInt32(35 * C.MeshFactor)); //35 _xNodes2 = _xNodes2.GetSubVector(0, (_xNodes2.Length - 1)); var _xNodes3 = Grid1D.TanhSpacing(2, 20, Convert.ToInt32(60 * C.MeshFactor), 1.5, true); //60 var xNodes = ArrayTools.Cat(_xNodes1, _xNodes2, _xNodes3); var _yNodes1 = Grid1D.TanhSpacing(-2, -1, Convert.ToInt32(7 * C.MeshFactor), 0.9, false); //7 _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); var _yNodes2 = GenericBlas.Linspace(-1, 1, Convert.ToInt32(25 * C.MeshFactor)); //25 _yNodes2 = _yNodes2.GetSubVector(0, (_yNodes2.Length - 1)); var _yNodes3 = Grid1D.TanhSpacing(1, 2.1, Convert.ToInt32(7 * C.MeshFactor), 1.1, true); //7 var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2, _yNodes3); //double[] xNodes = GenericBlas.Linspace(0 * BaseSize, 22 * BaseSize, 25); //double[] yNodes = GenericBlas.Linspace(0 * BaseSize, 4.1 * BaseSize, 25); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: xPeriodic); grd.EdgeTagNames.Add(1, "Velocity_Inlet_upper"); grd.EdgeTagNames.Add(2, "Velocity_Inlet_lower"); if (!xPeriodic) { grd.EdgeTagNames.Add(3, "Velocity_Inlet_left"); grd.EdgeTagNames.Add(4, "Pressure_Outlet_right"); } grd.DefineEdgeTags(delegate(double[] X) { byte et = 0; if (Math.Abs(X[1] - (-2 * BaseSize)) <= 1.0e-8) { et = 1; } if (Math.Abs(X[1] - (+2.1 * BaseSize)) <= 1.0e-8) { et = 2; } if (!xPeriodic && Math.Abs(X[0] - (-2 * BaseSize)) <= 1.0e-8) { et = 3; } if (!xPeriodic && Math.Abs(X[0] - (+20.0 * BaseSize)) <= 1.0e-8) { et = 4; } Debug.Assert(et != 0); return(et); }); Console.WriteLine("Cells: {0}", grd.NumberOfCells); return(grd); }; //C.GridFunc = delegate { // // Box1 // var box1_p1 = new double[2] { -2, -2 }; // var box1_p2 = new double[2] { 20, 2.1 }; // var box1 = new GridBox(box1_p1, box1_p2, 46, 20); //k1: 70,25 ; k2: 46,20 ; k3: 35,15 // // Box2 // var box2_p1 = new double[2] { -2, -2 }; // var box2_p2 = new double[2] { 3, 2.1 }; // var box2 = new GridBox(box2_p1, box2_p2, 26, 40); //k1: 40,50 ; k2: 26,40; k3: 20, 30 // // Box3 // var box3_p1 = new double[2] { -2, -1 }; // var box3_p2 = new double[2] { 1, 1 }; // var box3 = new GridBox(box3_p1, box3_p2, 32, 38); //k1: 48,58 ; k2: 32,38; k3: 24, 30 // // Box4 // var box4_p1 = new double[2] { -0.7, -0.72 }; // var box4_p2 = new double[2] { 0.7, 0.7 }; // var box4 = new GridBox(box4_p1, box4_p2, 30, 56); //k1: 44,84 ; k2: 30,56; k3: 22, 42 // var grd = Grid2D.HangingNodes2D(box1, box2, box3,box4); // grd.EdgeTagNames.Add(1, "Velocity_Inlet_upper"); // grd.EdgeTagNames.Add(2, "Velocity_Inlet_lower"); // if (!xPeriodic) { // grd.EdgeTagNames.Add(3, "Velocity_Inlet_left"); // grd.EdgeTagNames.Add(4, "Pressure_Outlet_right"); // } // grd.DefineEdgeTags(delegate (double[] X) { // byte et = 0; // if (Math.Abs(X[1] - (-2 * BaseSize)) <= 1.0e-8) // et = 1; // if (Math.Abs(X[1] - (+2.1 * BaseSize)) <= 1.0e-8) // et = 2; // if (!xPeriodic && Math.Abs(X[0] - (-2 * BaseSize)) <= 1.0e-8) // et = 3; // if (!xPeriodic && Math.Abs(X[0] - (+20.0 * BaseSize)) <= 1.0e-8) // et = 4; // Debug.Assert(et != 0); // return et; // }); // Console.WriteLine("Cells: {0}", grd.NumberOfCells); // return grd; //}; C.AddBoundaryCondition("Velocity_Inlet_upper", "VelocityX", X => 0); C.AddBoundaryCondition("Velocity_Inlet_lower", "VelocityX", X => 0); //-(4 * 1.5 * X[1] * (4.1 - X[1]) / (4.1 * 4.1)) if (!xPeriodic) { C.AddBoundaryCondition("Velocity_Inlet_left", "VelocityX", X => (4 * 1.5 * (X[1] + 2) * (4.1 - (X[1] + 2)) / (4.1 * 4.1))); //C.AddBoundaryCondition("Velocity_Inlet_left", "VelocityX#A", X => 1); } C.AddBoundaryCondition("Pressure_Outlet_right"); // Initial Values // ============== double radius = 0.5; C.PhysicalParameters.rho_A = 1; C.PhysicalParameters.mu_A = 1.0 / 20; //C.InitialValues.Add("Phi", X => phi(X, 0)); //C.InitialValues.Add("Phi", X => ((X[0] / (radius * BaseSize)) - mPx) * (X[0] / (radius * BaseSize)) - mPx) + ((X[1]) / (radius * BaseSize)) - 2.)Pow2() - radius.Pow2())); // quadratic form // ); C.InitialValues_Evaluators.Add("Phi", X => - (X[0]).Pow2() + -(X[1]).Pow2() + radius.Pow2()); //C.InitialValues.Add("Phi", X => -1); C.InitialValues_Evaluators.Add("VelocityX", X => 4 * 1.5 * (X[1] + 2) * (4.1 - (X[1] + 2)) / (4.1 * 4.1)); //C.InitialValues.Add("VelocityX", delegate (double[] X) //{ // double x = X[0]; // double y = X[1]; // double R = Math.Sqrt((x + 1).Pow2() + y.Pow2()); // double xVel = 0; // if (R < 0.75) // { // xVel = 1; // } // return xVel; //}); //C.InitialValues.Add("VelocityY", delegate (double[] X) { // double x = X[0]; // double y = X[1]; // double R = Math.Sqrt((x + 1).Pow2() + (y).Pow2()); // double yVel = 0; // if (R < 0.75) { // yVel = 1; // } // return yVel; //}); // For restart //C.RestartInfo = new Tuple<Guid, TimestepNumber>(new Guid("8f5cfed9-31c7-4be8-aa56-e92e5348e08b"), 95); //C.GridGuid = new Guid("71ffc0c4-66aa-4762-b07e-45385f34b03f"); // Physical Parameters // =================== C.PhysicalParameters.IncludeConvection = true; // misc. solver options // ==================== C.AdvancedDiscretizationOptions.CellAgglomerationThreshold = 0.2; C.LevelSetSmoothing = false; //C.option_solver = "direct"; C.MaxKrylovDim = 20; C.MaxSolverIterations = 50; C.VelocityBlockPrecondMode = MultigridOperator.Mode.SymPart_DiagBlockEquilib_DropIndefinite; C.NoOfMultigridLevels = 0; // Timestepping // ============ C.Timestepper_Scheme = IBM_Control.TimesteppingScheme.ImplicitEuler; double dt = 0.05; C.dtMax = dt; C.dtMin = dt; C.Endtime = 70; C.NoOfTimesteps = 1000000; // haben fertig... // =============== R.Add(C); } return(R.ToArray()); }
/// <summary> /// Control for the testcase according to Smolianksi /// </summary> /// <param name="p"></param> /// <param name="kelem"></param> /// <param name="_DbPath"></param> /// <returns></returns> public static XNSE_Control RT_Smolianski(int p = 2, int kelem = 32, string _DbPath = null) { XNSE_Control C = new XNSE_Control(); // basic database options // ====================== #region db //_DbPath = @"D:\local\local_Testcase_databases\Testcase_RTinstability"; _DbPath = @"\\fdyprime\userspace\smuda\cluster\cluster_db"; C.DbPath = _DbPath; C.savetodb = C.DbPath != null; C.ProjectName = "XNSE/RT-Instability"; C.Tags.Add("unstable"); //C.Tags.Add("smolianski"); #endregion //C.LogValues = XNSE_Control.LoggingValues.Wavelike; //C.WriteInterfaceP = true; // DG degrees // ========== #region degrees C.FieldOptions.Add("VelocityX", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("VelocityY", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Pressure", new FieldOpts() { Degree = p - 1, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("PhiDG", new FieldOpts() { SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Phi", new FieldOpts() { Degree = 4, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Curvature", new FieldOpts() { Degree = 8, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); #endregion // grid genration // ============== #region grid double L = 1; double H = 4.0 * L; C.GridFunc = delegate() { // Smolianski //double[] Xnodes = GenericBlas.Linspace(0, L, kelem + 1); //double[] Ynodes = GenericBlas.Linspace(0, H, (4 * kelem) + 1); //var grd = Grid2D.Cartesian2DGrid(Xnodes, Ynodes, periodicX: false); double[] xNodes = GenericBlas.Linspace(0, L, kelem + 1); double[] _yNodes1 = GenericBlas.Linspace(0, 2.2, (int)(2.2 * kelem) + 1); _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); var _yNodes2 = Grid1D.TanhSpacing(2.2, 4.0, (kelem / 2) + 1, 1.5, true); var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: false); grd.EdgeTagNames.Add(1, "wall_lower"); grd.EdgeTagNames.Add(2, "wall_upper"); grd.EdgeTagNames.Add(3, "freeslip_left"); grd.EdgeTagNames.Add(4, "freeslip_right"); grd.DefineEdgeTags(delegate(double[] X) { byte et = 0; if (Math.Abs(X[1]) <= 1.0e-8) { et = 1; } if (Math.Abs(X[1] - H) <= 1.0e-8) { et = 2; } if (Math.Abs(X[0]) <= 1.0e-8) { et = 3; } if (Math.Abs(X[0] - L) <= 1.0e-8) { et = 4; } return(et); }); return(grd); }; //double L = 1; //lambda_instable; //double H = 1.0 * L; //double H_interf = L / 4.0; ////int xkelem = 20; //int ykelem_Interface = 1 * kelem / 2; //int ykelem_outer = kelem / 2; //C.GridFunc = delegate () { // double[] xNodes = GenericBlas.Linspace(0, L, kelem + 1); // //double[] Ynodes_Interface = GenericBlas.Linspace(-(H_interf) / 2.0, (H_interf) / 2.0, ykelem_Interface); // //Ynodes_Interface = Ynodes_Interface.GetSubVector(1, Ynodes_Interface.GetLength(0) - 2); // //double[] Ynodes_lower = GenericBlas.Linspace(-(H + (H_interf / 2.0)), -(H_interf / 2.0), ykelem_outer + 1); // //double[] Ynodes_upper = GenericBlas.Linspace((H_interf / 2.0), H + (H_interf / 2.0), ykelem_outer + 1); // //double[] Ynodes = Ynodes_lower.Concat(Ynodes_Interface).ToArray().Concat(Ynodes_upper).ToArray(); // var _yNodes1 = Grid1D.TanhSpacing(-(H + (H_interf / 2.0)), -(H_interf / 2.0), ykelem_outer + 1, 1.5, false); // _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); // var _yNodes2 = GenericBlas.Linspace(-H_interf / 2.0, H_interf / 2.0, ykelem_Interface); // _yNodes2 = _yNodes2.GetSubVector(0, (_yNodes2.Length - 1)); // var _yNodes3 = Grid1D.TanhSpacing((H_interf / 2.0), H + (H_interf / 2.0), ykelem_outer + 1, 1.5, true); // var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2, _yNodes3); // var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: true); // grd.EdgeTagNames.Add(1, "wall_lower"); // grd.EdgeTagNames.Add(2, "wall_upper"); // grd.DefineEdgeTags(delegate (double[] X) { // byte et = 0; // if (Math.Abs(X[1] + ((H_interf / 2.0) + H)) <= 1.0e-8) // et = 1; // if (Math.Abs(X[1] - ((H_interf / 2.0) + H)) <= 1.0e-8) // et = 2; // if (Math.Abs(X[0]) <= 1.0e-8) // et = 3; // if (Math.Abs(X[0] - L) <= 1.0e-8) // et = 4; // return et; // }); // return grd; //}; #endregion // boundary conditions // =================== #region BC C.AddBoundaryCondition("wall_lower"); C.AddBoundaryCondition("wall_upper"); C.AddBoundaryCondition("freeslip_left"); C.AddBoundaryCondition("freeslip_right"); #endregion // Initial Values // ============== #region init int k = 1; double A0 = 0.05; C.InitialValues_Evaluators.Add("Phi", (X => X[1] - (2.0 + A0 * Math.Cos(2.0 * Math.PI * X[0])))); C.InitialValues_Evaluators.Add("VelocityY#A", X => 0.0); C.InitialValues_Evaluators.Add("VelocityY#B", X => 0.0); double g = 1.0; C.InitialValues_Evaluators.Add("GravityY#A", X => - g); C.InitialValues_Evaluators.Add("GravityY#B", X => - g); //var database = new DatabaseInfo(_DbPath); //Guid restartID = new Guid("12b8c9f7-504c-40c4-a548-304a2e2aa14f"); //C.RestartInfo = new Tuple<Guid, Foundation.IO.TimestepNumber>(restartID, 3420); #endregion // Physical Parameters // =================== #region physics //C.PhysicalParameters.rho_A = 0.17; //C.PhysicalParameters.rho_B = 1.2; //C.PhysicalParameters.mu_A = 0.17e-2; //C.PhysicalParameters.mu_B = 1.2e-2; //C.PhysicalParameters.Sigma = 0.0; C.PhysicalParameters.rho_A = 0.17; C.PhysicalParameters.rho_B = 1.2; C.PhysicalParameters.mu_A = 0.003; C.PhysicalParameters.mu_B = 0.003; C.PhysicalParameters.Sigma = 0.0; // corresponding dt = 1e-3; //C.PhysicalParameters.Sigma = 0.015; // corresponding dt = 4e-3; C.PhysicalParameters.IncludeConvection = true; C.PhysicalParameters.Material = true; #endregion // additional parameters // ===================== //double[] param = new double[4]; //param[0] = k; // wavenumber //param[1] = L; // wavelength //param[2] = A0; // initial disturbance //param[3] = g; // y-gravity //C.AdditionalParameters = param; // misc. solver options // ==================== #region solver //C.AdvancedDiscretizationOptions.CellAgglomerationThreshold = 0.2; //C.AdvancedDiscretizationOptions.PenaltySafety = 40; //C.AdvancedDiscretizationOptions.UseGhostPenalties = true; C.LSContiProjectionMethod = ContinuityProjectionOption.SpecFEM; C.VelocityBlockPrecondMode = MultigridOperator.Mode.SymPart_DiagBlockEquilib; C.Solver_MaxIterations = 50; C.Solver_ConvergenceCriterion = 1e-8; C.LevelSet_ConvergenceCriterion = 1e-6; C.LinearSolver = new DirectSolver() { WhichSolver = DirectSolver._whichSolver.MUMPS }; C.AdvancedDiscretizationOptions.FilterConfiguration = CurvatureAlgorithms.FilterConfiguration.Default; C.AdvancedDiscretizationOptions.SST_isotropicMode = Solution.XNSECommon.SurfaceStressTensor_IsotropicMode.Curvature_Projected; C.AdvancedDiscretizationOptions.FilterConfiguration.FilterCurvatureCycles = 1; #endregion // Timestepping // ============ #region time C.CompMode = AppControl._CompMode.Transient; C.Timestepper_Scheme = XNSE_Control.TimesteppingScheme.ImplicitEuler; C.Timestepper_BDFinit = TimeStepperInit.SingleInit; //C.dt_increment = 20; C.Timestepper_LevelSetHandling = LevelSetHandling.LieSplitting; double dt = 1e-3; C.dtMax = dt; C.dtMin = dt; C.Endtime = 1000; C.NoOfTimesteps = 4000; C.saveperiod = 4; #endregion return(C); }
/// <summary> /// Template for all shock tube tests /// </summary> /// <param name="convectiveFlux"></param> /// <param name="densityLeft"></param> /// <param name="velocityLeft"></param> /// <param name="pressureLeft"></param> /// <param name="densityRight"></param> /// <param name="velocityRight"></param> /// <param name="pressureRight"></param> /// <param name="discontinuityPosition"></param> /// <returns></returns> private static CNSControl GetShockTubeControlTemplate(ConvectiveFluxTypes convectiveFlux, double densityLeft, double velocityLeft, double pressureLeft, double densityRight, double velocityRight, double pressureRight, double discontinuityPosition) { CNSControl c = new CNSControl(); c.DbPath = null; c.savetodb = false; c.ActiveOperators = Operators.Convection; c.ConvectiveFluxType = convectiveFlux; c.EquationOfState = IdealGas.Air; c.MachNumber = 1.0 / Math.Sqrt(c.EquationOfState.HeatCapacityRatio); c.ExplicitScheme = ExplicitSchemes.RungeKutta; c.ExplicitOrder = 1; int dgDegree = 0; c.AddVariable(Variables.Density, dgDegree); c.AddVariable(Variables.Momentum.xComponent, dgDegree); c.AddVariable(Variables.Energy, dgDegree); c.AddVariable(Variables.Pressure, dgDegree); c.AddVariable(Variables.Velocity.xComponent, dgDegree); c.GridFunc = delegate { double[] xNodes = GenericBlas.Linspace(0.0, 1.0, 201); var grid = Grid1D.LineGrid(xNodes, false); grid.EdgeTagNames.Add(1, "supersonicOutlet"); grid.DefineEdgeTags(X => 1); return(grid); }; // Take inner values everywhere c.AddBoundaryCondition("supersonicOutlet"); Material material = new Material(c); StateVector stateLeft = StateVector.FromPrimitiveQuantities( material, densityLeft, new Vector3D(velocityLeft, 0.0, 0.0), pressureLeft); StateVector stateRight = StateVector.FromPrimitiveQuantities( material, densityRight, new Vector3D(velocityRight, 0.0, 0.0), pressureRight); c.InitialValues_Evaluators.Add( Variables.Density, X => stateLeft.Density + (stateRight.Density - stateLeft.Density) * (X[0] - discontinuityPosition).Heaviside()); c.InitialValues_Evaluators.Add( Variables.Velocity.xComponent, X => stateLeft.Velocity.x + (stateRight.Velocity.x - stateLeft.Velocity.x) * (X[0] - discontinuityPosition).Heaviside()); c.InitialValues_Evaluators.Add( Variables.Pressure, X => stateLeft.Pressure + (stateRight.Pressure - stateLeft.Pressure) * (X[0] - discontinuityPosition).Heaviside()); var riemannSolver = new ExactRiemannSolver(stateLeft, stateRight, new Vector3D(1.0, 0.0, 0.0)); double pStar, uStar; riemannSolver.GetStarRegionValues(out pStar, out uStar); c.Queries.Add("L2ErrorDensity", QueryLibrary.L2Error( Variables.Density, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Density)); c.Queries.Add("L2ErrorVelocity", QueryLibrary.L2Error( Variables.Velocity.xComponent, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Velocity.x)); c.Queries.Add("L2ErrorPressure", QueryLibrary.L2Error( Variables.Pressure, (X, t) => riemannSolver.GetState(pStar, uStar, X[0] - discontinuityPosition, t).Pressure)); c.dtMin = 0.0; c.dtMax = 1.0; c.CFLFraction = 0.5; c.NoOfTimesteps = int.MaxValue; c.PrintInterval = 50; return(c); }
/// <summary> /// Control for various testing /// </summary> /// <param name="p"></param> /// <param name="xkelem"></param> /// <param name="dt"></param> /// <param name="t_end"></param> /// <param name="_DbPath"></param> /// <returns></returns> public static XNSE_Control RT(int p = 2, int xkelem = 16, string _DbPath = null) { XNSE_Control C = new XNSE_Control(); // basic database options // ====================== #region db _DbPath = @"D:\local\local_Testcase_databases\Testcase_RTinstability"; //_DbPath = @"\\fdyprime\userspace\smuda\cluster\cluster_db"; C.DbPath = _DbPath; C.savetodb = C.DbPath != null; C.ProjectName = "XNSE/RT-Instability"; C.LogValues = XNSE_Control.LoggingValues.Wavelike; C.WriteInterfaceP = true; #endregion // DG degrees // ========== #region degrees C.FieldOptions.Add("VelocityX", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("VelocityY", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Pressure", new FieldOpts() { Degree = p - 1, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("GravityY", new FieldOpts() { SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("PhiDG", new FieldOpts() { SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Phi", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); C.FieldOptions.Add("Curvature", new FieldOpts() { Degree = p, SaveToDB = FieldOpts.SaveToDBOpt.TRUE }); #endregion // Physical Parameters // =================== #region physics // Capillary wave: Laplace number La = 3e5: //C.Tags.Add("La=3e5"); //double rho_l = 1e-3; //double rho_h = 1e-3; //double mu_l = 1e-5; //double mu_h = 1e-5; //double sigma = 3e-2; // Capillary wave: Laplace number La = 3000: //C.Tags.Add("La3000"); //double rho_l = 1e-3; //double rho_h = 1e-3; //double mu_l = 1e-4; //double mu_h = 1e-4; //double sigma = 3e-2; // Capillary wave: Laplace number La = 120: //double rho_l = 1e-3; //double rho_h = 1e-3; //double mu_l = 5e-4; //double mu_h = 5e-4; //double sigma = 3e-2; //double rho_l = 1e-3; //double rho_h = 1e-3; //double mu_l = 1e-6; //double mu_h = 1e-4; //double sigma = 3e-2; //double rho_l = 1; //double rho_h = 1; //double mu_l = 1e-3; //double mu_h = 1e-3; //double sigma = 1; // Air(light)-Water(heavy) //double rho_h = 1e-3; // kg / cm^3 //double rho_l = 1.2e-6; // kg / cm^3 //double mu_h = 1e-5; // kg / cm * s //double mu_l = 17.1e-8; // kg / cm * s //double sigma = 72.75e-3; // kg / s^2 // lambda_crit = 1.7121 ; lambda < lambda_c: stable // same kinematic viscosities //double rho_l = 1e-5; // kg / cm^3 //double mu_l = 1e-8; // kg / cm * s //double rho_h = 1e-3; // kg / cm^3 //double mu_h = 1e-6; // kg / cm * s // Atwood number = 0.98 //double rho_l = 7e-4; // kg / cm^3 //double mu_l = 7e-5; // kg / cm * s //double rho_h = 1e-3; // kg / cm^3 //double mu_h = 1e-4; // kg / cm * s // Atwood number = 0.1765 //double sigma = 72.75e-3; // kg / s^2 //double rho_l = 1e-3; //double mu_l = 1e-4; //double rho_h = 1; //double mu_h = 1e-1; //double sigma = 100; // kg / s^2 double rho_l = 1e-1; double mu_l = 1e-2; double rho_h = 10; double mu_h = 1; double sigma = 50; // kg / s^2 // Water-Oil //double rho_ = 8.63e-4; //double rho_B = 1.2e-6; //double mu_A = 2e-4; //double mu_B = 17.1e-8; // stable configuration //C.PhysicalParameters.rho_A = rho_h; //C.PhysicalParameters.rho_B = rho_l; //C.PhysicalParameters.mu_A = mu_h; //C.PhysicalParameters.mu_B = mu_l; //C.PhysicalParameters.Sigma = sigma; // unstable configuration C.PhysicalParameters.rho_A = rho_l; C.PhysicalParameters.rho_B = rho_h; C.PhysicalParameters.mu_A = mu_l; C.PhysicalParameters.mu_B = mu_h; C.PhysicalParameters.Sigma = sigma; //C.PhysicalParameters.Sigma = 0.0; // free surface boundary condition C.PhysicalParameters.IncludeConvection = true; C.PhysicalParameters.Material = true; #endregion // Initial displacement // =================== int kmode = 1; double H0 = 0.01; //double lambda_stable = 1; //double lambda_instable = 4; //Func<double, double> displacement = x => ((lambda_stable / 100) * Math.Sin(x * 2 * Math.PI / lambda_stable )) + ((lambda_instable / 100) * Math.Sin(x * 2 * Math.PI / lambda_instable)); Func <double, double> displacement = x => (H0 * Math.Sin(x * 2 * Math.PI * (double)kmode)); // grid genration // ============== #region grid double L = 1; //lambda_instable; double H = 1.0 * L; double H_interf = L / 4.0; //int xkelem = 20; int ykelem_Interface = 1 * xkelem; // /2 int ykelem_outer = xkelem / 2; // /2 C.GridFunc = delegate() { double[] xNodes = GenericBlas.Linspace(0, L, xkelem + 1); //double[] Ynodes_Interface = GenericBlas.Linspace(-(H_interf) / 2.0, (H_interf) / 2.0, ykelem_Interface); //Ynodes_Interface = Ynodes_Interface.GetSubVector(1, Ynodes_Interface.GetLength(0) - 2); //double[] Ynodes_lower = GenericBlas.Linspace(-(H + (H_interf / 2.0)), -(H_interf / 2.0), ykelem_outer + 1); //double[] Ynodes_upper = GenericBlas.Linspace((H_interf / 2.0), H + (H_interf / 2.0), ykelem_outer + 1); //double[] Ynodes = Ynodes_lower.Concat(Ynodes_Interface).ToArray().Concat(Ynodes_upper).ToArray(); var _yNodes1 = Grid1D.TanhSpacing(-(H + (H_interf / 2.0)), -(H_interf / 2.0), ykelem_outer + 1, 1.5, false); _yNodes1 = _yNodes1.GetSubVector(0, (_yNodes1.Length - 1)); var _yNodes2 = GenericBlas.Linspace(-H_interf / 2.0, H_interf / 2.0, ykelem_Interface); _yNodes2 = _yNodes2.GetSubVector(0, (_yNodes2.Length - 1)); var _yNodes3 = Grid1D.TanhSpacing((H_interf / 2.0), H + (H_interf / 2.0), ykelem_outer + 1, 1.5, true); var yNodes = ArrayTools.Cat(_yNodes1, _yNodes2, _yNodes3); var grd = Grid2D.Cartesian2DGrid(xNodes, yNodes, periodicX: true); grd.EdgeTagNames.Add(1, "wall_lower"); grd.EdgeTagNames.Add(2, "wall_upper"); grd.DefineEdgeTags(delegate(double[] X) { byte et = 0; if (Math.Abs(X[1] + ((H_interf / 2.0) + H)) <= 1.0e-8) { et = 1; } if (Math.Abs(X[1] - ((H_interf / 2.0) + H)) <= 1.0e-8) { et = 2; } if (Math.Abs(X[0]) <= 1.0e-8) { et = 3; } if (Math.Abs(X[0] - L) <= 1.0e-8) { et = 4; } return(et); }); return(grd); }; // nach Popinet //C.GridFunc = delegate () { // double[] Xnodes = GenericBlas.Linspace(0, L, xkelem + 1); // double[] Ynodes = GenericBlas.Linspace(-3.0 * L / 2.0, 3.0 * L / 2.0, (3 * xkelem) + 1); // var grd = Grid2D.Cartesian2DGrid(Xnodes, Ynodes, periodicX: true); // grd.EdgeTagNames.Add(1, "wall_lower"); // grd.EdgeTagNames.Add(2, "wall_upper"); // grd.DefineEdgeTags(delegate (double[] X) { // byte et = 0; // if (Math.Abs(X[1] + (3.0 * L / 2.0)) <= 1.0e-8) // et = 1; // if (Math.Abs(X[1] - (3.0 * L / 2.0)) <= 1.0e-8) // et = 2; // if (Math.Abs(X[0]) <= 1.0e-8) // et = 3; // if (Math.Abs(X[0] - L) <= 1.0e-8) // et = 4; // return et; // }); // return grd; //}; #endregion // boundary conditions // =================== #region BC C.AddBoundaryCondition("wall_lower"); C.AddBoundaryCondition("wall_upper"); #endregion // Initial Values // ============== #region init Func <double, double> PeriodicFunc = x => displacement(x); //superposed higher frequent disturbance //double lambda_dist = lambda / (double)(xkelem / 2); //if (lambda_dist > 0.0) { // double A0_dist = A0 / 5.0; // Func<double, double> disturbance = x => A0_dist * Math.Sin(x * 2 * Math.PI / lambda_dist); // PeriodicFunc = x => (displacement(x) + disturbance(x)); //} C.InitialValues_Evaluators.Add("Phi", (X => X[1] - (PeriodicFunc(X[0])))); C.InitialValues_Evaluators.Add("VelocityX#A", X => 0.0); C.InitialValues_Evaluators.Add("VelocityX#B", X => 0.0); double g = 9.81; // e2; C.InitialValues_Evaluators.Add("GravityY#A", X => - g); C.InitialValues_Evaluators.Add("GravityY#B", X => - g); //var database = new DatabaseInfo(_DbPath); //Guid restartID = new Guid("0141eba2-8d7b-4593-8595-bfff12dbfc40"); //C.RestartInfo = new Tuple<Guid, Foundation.IO.TimestepNumber>(restartID, null); #endregion // misc. solver options // ==================== #region solver //C.AdvancedDiscretizationOptions.CellAgglomerationThreshold = 0.2; //C.AdvancedDiscretizationOptions.PenaltySafety = 40; //C.AdvancedDiscretizationOptions.UseGhostPenalties = true; C.LSContiProjectionMethod = ContinuityProjectionOption.SpecFEM; C.VelocityBlockPrecondMode = MultigridOperator.Mode.SymPart_DiagBlockEquilib; C.NoOfMultigridLevels = 1; C.Solver_MaxIterations = 50; C.Solver_ConvergenceCriterion = 1e-8; C.LevelSet_ConvergenceCriterion = 1e-6; C.LinearSolver = new DirectSolver() { WhichSolver = DirectSolver._whichSolver.MUMPS }; //C.Option_LevelSetEvolution = LevelSetEvolution.Fourier; //C.AdvancedDiscretizationOptions.surfTensionMode = SurfaceTensionMode.Curvature_Fourier; C.AdvancedDiscretizationOptions.FilterConfiguration = CurvatureAlgorithms.FilterConfiguration.Default; C.AdvancedDiscretizationOptions.SST_isotropicMode = Solution.XNSECommon.SurfaceStressTensor_IsotropicMode.Curvature_Projected; C.AdvancedDiscretizationOptions.FilterConfiguration.FilterCurvatureCycles = 1; #endregion // additional parameters // ===================== double[] param = new double[4]; param[0] = kmode; // wavenumber param[1] = L; // wavelength param[2] = H0; // initial disturbance param[3] = g; // y-gravity C.AdditionalParameters = param; // specialized Fourier Level-Set // ============================= int numSp = 640; //C.FourierLevSetControl = new FourierLevSetControl(FourierType.Planar, numSp, L, PeriodicFunc, 1.0 / (double)xkelem) { // FourierEvolve = Fourier_Evolution.MaterialPoints, // Timestepper = FourierLevelSet_Timestepper.RungeKutta1901, // InterpolationType = Interpolationtype.CubicSplineInterpolation //}; // Timestepping // ============ #region time C.CompMode = AppControl._CompMode.Transient; C.Timestepper_Scheme = XNSE_Control.TimesteppingScheme.ImplicitEuler; C.Timestepper_BDFinit = TimeStepperInit.SingleInit; //C.dt_increment = 20; C.Timestepper_LevelSetHandling = LevelSetHandling.LieSplitting; double dt = 1e-4; C.dtMax = dt; C.dtMin = dt; C.Endtime = 1000; C.NoOfTimesteps = 4000; C.saveperiod = 4; #endregion return(C); }
/// <summary> /// 1D Manufactured solution for the Euler equations with variable Mach number /// </summary> /// <param name="dgDegree"></param> /// <param name="noOfCellsPerDirection"></param> /// <returns></returns> public static CNSControl Euler1D(int dgDegree, int noOfCellsPerDirection) { CNSControl c = new CNSControl(); c.PrintInterval = 1; c.ResidualInterval = 1; c.saveperiod = 1; c.DbPath = @""; c.savetodb = false; c.Tags.Add("MMS"); c.ActiveOperators = Operators.Convection | Operators.CustomSource; c.ConvectiveFluxType = ConvectiveFluxTypes.Rusanov; c.ExplicitScheme = ExplicitSchemes.RungeKutta; c.ExplicitOrder = 1; c.EquationOfState = IdealGas.Air; c.AddVariable(Variables.Density, dgDegree); c.AddVariable(Variables.Momentum.xComponent, dgDegree); c.AddVariable(Variables.Energy, dgDegree); c.AddVariable(Variables.Velocity.xComponent, dgDegree); c.AddVariable(Variables.Pressure, dgDegree); c.AddVariable(Variables.LocalMachNumber, dgDegree); c.GridFunc = delegate { double[] nodes = GenericBlas.Linspace(0.0, 1.0, noOfCellsPerDirection + 1); var grid = Grid1D.LineGrid(nodes); grid.EdgeTagNames.Add(1, "supersonicinlet"); grid.DefineEdgeTags(X => 1); return(grid); }; double gamma = c.EquationOfState.HeatCapacityRatio; c.MachNumber = 1 / Math.Sqrt(gamma); double a = 2.0 * Math.PI; double b = 0.25; double c1 = 2.0; double MachScaling = (gamma * c.MachNumber * c.MachNumber); Func <double[], double, double> rho = (X, t) => c1 + b * Math.Sin(a * X[0]); Func <double[], double, double> m0 = (X, t) => c1 + b * Math.Sin(a * X[0]); Func <double[], double, double> rhoE = (X, t) => (c1 + b * Math.Sin(a * X[0])) * (c1 + b * Math.Sin(a * X[0])); Func <double[], double, double> u0 = (X, t) => 1; Func <double[], double, double> p = (X, t) => (gamma - 1) * (rhoE(X, t) - 0.5 * MachScaling * rho(X, t) * u0(X, t) * u0(X, t)); c.InitialValues_Evaluators.Add(Variables.Density, X => rho(X, 0.0)); c.InitialValues_Evaluators.Add(Variables.Momentum.xComponent, X => m0(X, 0.0)); c.InitialValues_Evaluators.Add(Variables.Energy, X => rhoE(X, 0.0)); c.AddBoundaryCondition("supersonicInlet", Variables.Density, rho); c.AddBoundaryCondition("supersonicInlet", Variables.Velocity.xComponent, u0); c.AddBoundaryCondition("supersonicInlet", Variables.Pressure, p); // MMS Sources c.CustomContinuitySources.Add(map => new AdHocSourceTerm(map, (X, t, state) => - (a * b * Math.Cos(a * X[0])) )); c.CustomMomentumSources[0].Add(map => new AdHocSourceTerm(map, (X, t, state) => - ((a * b * Math.Cos(a * X[0])) * (1 + (gamma - 1) / MachScaling * (2 * rho(X, t) - 0.5 * MachScaling))) )); c.CustomEnergySources.Add(map => new AdHocSourceTerm(map, (X, t, state) => - ((a * b * Math.Cos(a * X[0])) * (2 * rho(X, t) + (gamma - 1) * (2 * rho(X, t) - 0.5 * MachScaling))) )); c.Queries.Add("L2ErrorDensity", QueryLibrary.L2Error(Variables.Density, rho)); c.Queries.Add("L2ErrorPressure", QueryLibrary.L2Error(Variables.Pressure, p)); c.Queries.Add("L2ErrorVelocity", QueryLibrary.L2Error(Variables.Velocity.xComponent, u0)); c.dtMin = 0.0; c.dtMax = 1.0; c.CFLFraction = 0.4; c.Endtime = 10000.0; c.NoOfTimesteps = int.MaxValue; c.ResidualLoggerType = ResidualLoggerTypes.ChangeRate | ResidualLoggerTypes.Query; c.ResidualBasedTerminationCriteria.Add("changeRate_abs_rhoE", 1E-14); c.ProjectName = "MMS_Euler1D_Flux=" + c.ConvectiveFluxType + "dg=" + dgDegree + "_cells=" + noOfCellsPerDirection; return(c); }