示例#1
0
        public static List <int> GetBaseCellSizes(CFDMesh meshConfig, Dictionary <string, object> overrides)
        {
            if (overrides != null && overrides.ContainsKey("mesh_independence"))
            {
                var meshIndependenceOverrides = overrides["mesh_independence"].ToDictionary();
                if (meshIndependenceOverrides.ContainsKey("cell_sizes"))
                {
                    return(((object[])meshIndependenceOverrides["cell_sizes"]).Cast <int>().ToList());
                }
            }

            var defaultSize = (int)meshConfig.BaseMesh.CellSize;
            var smallSize   = defaultSize - 4;
            var largeSize   = defaultSize + 4;

            if (defaultSize > 4)
            {
                return new List <int> {
                           smallSize, defaultSize, largeSize
                }
            }
            ;

            smallSize = (int)(defaultSize / 2);
            largeSize = defaultSize + smallSize;

            return(new List <int> {
                smallSize, defaultSize, largeSize
            });
        }
    }
示例#2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var prototype = new CFDMesh(
                new double[] { 0.0, 0.5, 0.8 },
                new double[] { 0.0, 0.0, 1.0 },
                new double[] { 0.0, -0.5, +0.25 },
                new List <Tuple <int, int> >()
            {
                Tuple.Create(0, 1),
                Tuple.Create(0, 2),
                Tuple.Create(1, 2)
            }
                );

            var derived = prototype.Clone();

            derived.ChangeXCoordinates(new double[] { -1.0, -2.0, -3.0 });
        }
示例#3
0
        public static List <Task> CreateMeshIndependenceTasks(
            AuthTokens tokens,
            string url,
            string projectId,
            string parentTaskId,
            string actionTaskId,
            bool includeSetSet,
            CFDSolution solution,
            CFDMesh meshConfig,
            bool create
            )
        {
            var overrides = solution.Overrides;
            var cpus      = solution.CPUs;
            var path      = $"/api/project/{projectId}/task/";
            var parentIndependenceTask = Utils.CreateParent(
                tokens,
                url,
                path,
                "Mesh Independence Study",
                new Dictionary <string, object> {
                { "parent", parentTaskId }
            },
                create);
            var tasks = new List <Task> {
                parentIndependenceTask
            };

            var cellSizes         = GetBaseCellSizes(meshConfig, overrides);
            var duplicateBaseMesh = (BaseMesh)meshConfig.BaseMesh.Clone();
            var duplicateSolution = (CFDSolution)solution.Clone();

            duplicateSolution.CaseType = "SimpleCase";

            foreach (var cellSize in cellSizes)
            {
                var parentTask = Utils.CreateParent(
                    tokens,
                    url,
                    path,
                    $"Cell Size {cellSize}",
                    new Dictionary <string, object> {
                    { "parent", parentIndependenceTask.UID }, { "case_dir", $"independence/mesh_{cellSize}/foam" }, { "show_meta_data", true }
                },
                    create);
                tasks.Add(parentTask);

                // create action task
                duplicateBaseMesh.CellSize = cellSize;
                var actionTask = Action.CreateIndependenceActionTask(
                    tokens,
                    url,
                    path,
                    parentTask.UID,
                    actionTaskId,
                    duplicateBaseMesh,
                    create
                    );
                tasks.Add(actionTask);

                // create mesh
                var meshTask = CreateMeshTask(tokens, url, projectId, parentTask.UID, actionTask.UID, cpus,
                                              includeSetSet, overrides, create);
                tasks.Add(meshTask);

                // create solver task
                var cfdTask = CFD.CreateSimpleCase(tokens, url, path, parentTask.UID, meshTask.UID, duplicateSolution, create);
                tasks.Add(cfdTask);
            }

            return(tasks);
        }
        public static Task CreateCFDActionTask(
            AuthTokens tokens,
            string url,
            string path,
            string parentId,
            CFDMesh meshData,
            CFDSolution solution,
            int geometryFileSize,
            Dictionary <string, object> overrides,
            bool create
            )
        {
            if (overrides != null && overrides.ContainsKey("keep_mesh") && (bool)overrides["keep_mesh"])
            {
                create = false;
            }

            var actionTask = new GenericViewSet <Task>(
                tokens,
                url,
                path
                ).GetOrCreate(
                new Dictionary <string, object>
            {
                { "name", "Actions" },
                { "parent", parentId }
            },
                new Dictionary <string, object>
            {
                {
                    "config", new Dictionary <string, object>
                    {
                        { "task_type", "magpy" },
                        { "cmd", "cfd.io.tasks.write_mesh" },
                        { "base_mesh", meshData.BaseMesh },
                        { "snappyhex_mesh", meshData.SnappyHexMesh.ToDict() },
                    }
                }
            },
                create
                );

            // Then Action Task to create CFD files
            if (create)
            {
                if (solution != null && geometryFileSize > 0)
                {
                    new GenericViewSet <Task>(
                        tokens,
                        url,
                        path
                        ).Update(
                        actionTask.UID,
                        new Dictionary <string, object>
                    {
                        { "name", "Actions" },
                        { "status", "pending" },
                        {
                            "config", new Dictionary <string, object>
                            {
                                { "task_type", "magpy" },
                                { "cmd", "cfd.io.tasks.write_solution" },
                                { "solution", solution }
                            }
                        }
                    }
                        );
                }
                else
                {
                    // TODO - We need to handle if there is no solution given. Then we need to create the controlDict so people can do the meshing.
                }
            }

            return(actionTask);
        }