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
});
}
}
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 });
}
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);
}
