public static void UploadEPWFile(
AuthTokens tokens,
string url,
string taskId,
string epwFile
)
{
var epwFileContent = File.ReadAllBytes(epwFile);
var epwName = Path.GetFileName(epwFile);
{
// Upload EPW File to parent task
var uploadTask = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/weather/{epwName}"
).Update(
null,
new Dictionary <string, object>
{
{ "file", epwFileContent }
}
);
if (uploadTask.ContainsKey("error_messages"))
{
throw new Exception(uploadTask["error_messages"].ToString());
}
}
}
public static string GetFileList(
string inputJson,
string exclude,
string include
)
{
var inputData = new Inputs().FromJson(inputJson);
// Unpack to an AuthToken instances
var tokens = inputData.Auth;
var taskId = inputData.Task.UID;
var queryParams = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(exclude))
{
queryParams.Add("exclude", exclude);
}
if (!string.IsNullOrEmpty(include))
{
queryParams.Add("pattern", include);
}
var files = new GenericViewSet <TaskFile>(
tokens,
inputData.Url,
$"/api/task/{taskId}/file/"
).List(queryParams);
return(string.Join(",", files.Select(file => file.File)));
}
public static Dictionary <string, object> GetOrCreate(
string inputJson,
string projectName,
int projectNumber,
string taskName,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
// Unpack to an AuthToken instances
var tokens = inputData.Auth;
// Get a list of Projects for this user
var project = new GenericViewSet <Project>(
tokens,
$"{inputData.Url}/api/project/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", projectName },
{ "number", projectNumber }
},
null,
create
);
// We won't get here unless the last getting of Project succeeded
// Create the task if the Project succeeded
var task = new GenericViewSet <Task>(
tokens,
$"{inputData.Url}/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", taskName }
},
new Dictionary <string, object>
{
{
"config", new Dictionary <string, string>
{
{ "case_dir", "foam" },
{ "task_type", "parent" } // This is optional - task types of "parent" will not execute jobs
}
}
},
create
);
// We could have a function here that makes life easier to
// merge the outputs with the provided inputs
inputData.Task = task;
inputData.Project = project;
var output = inputData.ToJson();
return(new Dictionary <string, object>
{
{ "out", output }
});
}
private static Task SendCFDTask(
AuthTokens tokens,
string url,
string path,
CFDSolution solution,
string parentTaskId,
string dependentOnId,
Dictionary <string, object> createParams,
bool create
)
{
var queryParams = new Dictionary <string, object>
{
{ "name", solution.CaseType },
{ "parent", parentTaskId }
};
if (!string.IsNullOrEmpty(dependentOnId))
{
createParams.Add("dependent_on", dependentOnId);
}
var cfdTask = new GenericViewSet <Task>(
tokens,
url,
path
).GetOrCreate(
queryParams,
createParams,
create
);
return(cfdTask);
}
public static string UploadTextFile(string input, string path, string text, bool upload)
{
var inputData = new Inputs().FromJson(input);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
var response = new GenericViewSet <Dictionary <string, object> >(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "file", path },
},
new Dictionary <string, object>
{
{ "text", text }
},
upload
);
if (response.ContainsKey("file"))
{
return(inputData.Url + $"/project/${project.UID}/task/${parentTask.UID}/files/${path}/");
}
return("");
}
public static void UploadMeshFile(
AuthTokens tokens,
string url,
string taskId,
Dictionary <string, byte[]> meshFiles,
string caseDir = "geometry"
)
{
foreach (var name in meshFiles.Keys)
{
Logger.Info($"Uploading mesh: {name} to the server");
var upload = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/{caseDir}/{name}.obj"
).Update(
null,
new Dictionary <string, object>
{
{ "file", meshFiles[name] }
}
);
if (upload.ContainsKey("error_messages"))
{
Logger.Error(upload["error_messages"]);
throw new Exception($"Got error while uploading mesh to server: {upload["error_messages"]}");
}
Logger.Debug($"Uploaded {caseDir}/{name}.obj to server");
Thread.Sleep(100);
}
}
public static string GetTasks(
string inputJson,
string projectName,
int?projectNumber,
bool excludeChildren = true
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var queryParams = new Dictionary <string, object>
{
{ "name", projectName },
};
if (projectNumber != null)
{
queryParams.Add("number", projectNumber);
}
// Get a list of Projects for this user
var project = new GenericViewSet <Project>(
tokens,
inputData.Url,
"/api/project/"
).GetOrCreate(
queryParams,
null,
false
);
// We won't get here unless the last getting of Project succeeded
// Create the task if the Project succeeded
if (project.ErrorMessages != null)
{
throw new Exception(project.ErrorMessages.First());
}
var tasksQueryParams = new Dictionary <string, object>();
if (excludeChildren)
{
tasksQueryParams.Add("parent", "null");
}
var tasks = new GenericViewSet <Task>(
tokens,
inputData.Url,
$"/api/project/{project.UID}/task/"
).List(tasksQueryParams);
return(string.Join(";", tasks.Select(task => task.ToJson())));
}
public static void UploadGeometry(
AuthTokens tokens,
string url,
string taskId,
byte[] geometryFile,
string caseFolder,
string fileName,
List <Dictionary <string, byte[]> > refinementRegions = null
)
{
// Upload File to parent task
var geometryUpload = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/{caseFolder}/{fileName}.stl"
).Update(
null,
new Dictionary <string, object>
{
{ "file", geometryFile }
}
);
if (geometryUpload.ContainsKey("error_messages"))
{
Console.Write(geometryUpload["error_messages"]);
}
if (refinementRegions != null)
{
foreach (var refinementRegion in refinementRegions)
{
var refinementFileName = refinementRegion.Keys.First();
var file = refinementRegion[refinementFileName];
var refinementUpload = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/foam/constant/triSurface/{refinementFileName}.stl"
).Update(
null,
new Dictionary <string, object>
{
{ "file", file }
}
);
if (refinementUpload.ContainsKey("error_messages"))
{
Console.Write(refinementUpload["error_messages"]);
}
}
}
}
public static void UploadBSDFFile(
AuthTokens tokens,
string url,
string taskId,
List <RadianceMaterial> materials
)
{
foreach (var material in materials)
{
if (material.Overrides?.BSDF == null)
{
continue;
}
var bsdfIndex = 0;
foreach (var bsdfPath in material.Overrides.BSDFPath)
{
if (bsdfPath == "clear.xml")
{
bsdfIndex++;
continue;
}
var bsdfFileContent = File.ReadAllBytes(bsdfPath);
var uploadTask = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/bsdf/{material.Overrides.BSDF[bsdfIndex]}"
).Update(
null,
new Dictionary <string, object>
{
{ "file", bsdfFileContent }
}
);
if (uploadTask.ContainsKey("error_messages"))
{
throw new Exception(uploadTask["error_messages"].ToString());
}
bsdfIndex++;
}
if (material.Overrides.ScheduleValues != null)
{
UploadScheduleFiles(tokens, url, taskId, material);
}
}
}
public static Task GetDependentTask(
List <Task> subTasks,
string dependentName,
string url,
AuthTokens tokens,
string parentTaskId
)
{
if (subTasks == null)
{
return(null);
}
foreach (var subTask in subTasks.Where(subTask => !string.IsNullOrEmpty(subTask.UID))
.Where(subTask => dependentName == subTask.Name && subTask.Parent.UID == parentTaskId))
{
Logger.Info($"Found simulation task: {subTask.UID}");
return(subTask);
}
Logger.Info($"Did not find a simulation task with name: {dependentName}. Trying to fetch it.");
var queryParams = new Dictionary <string, object>
{
{ "name", dependentName },
{ "parent", parentTaskId },
};
try
{
var task = new GenericViewSet <Task>(
tokens,
url,
"/api/task/"
).GetByQueryParams(queryParams);
return(task);
}
catch (ArgumentException err)
{
if (err.Message != "No object found.")
{
Logger.Error($"Could not get Task. Got error: {err.Message}");
throw new ArgumentException(err.Message);
}
Logger.Info($"No task on the server with name: {dependentName}");
return(null);
}
}
public static void UploadScheduleFiles(
AuthTokens tokens,
string url,
string taskId,
RadianceMaterial material
)
{
var scheduleIndex = 0;
foreach (var schedule in material.Overrides.ScheduleValues)
{
var stream = new MemoryStream();
using (var memStream = new StreamWriter(stream))
{
memStream.Write(
$"{JsonConvert.SerializeObject(schedule)}");
}
var scheduleContent = stream.ToArray();
var scheduleName = $"{material.Name.Replace("*", "")}_{scheduleIndex}.json";
if (material.Overrides.Schedules == null)
{
material.Overrides.Schedules = new List <string>();
}
material.Overrides.Schedules.Add(scheduleName);
var uploadTask = new GenericViewSet <Dictionary <string, object> >(
tokens,
url,
$"/api/task/{taskId}/file/schedules/{scheduleName}"
).Update(
null,
new Dictionary <string, object>
{
{ "file", scheduleContent }
}
);
if (uploadTask.ContainsKey("error_messages"))
{
throw new Exception(uploadTask["error_messages"].ToString());
}
scheduleIndex++;
}
material.Overrides.ScheduleValues = null;
}
public void TestProjectList()
{
// Get the JWT access tokens as usual
var tokens = client.Auth(user.username, user.password);
Console.WriteLine($"Got access token: {tokens.Access}");
// Instantiate the Project object
//var projects = new ComputeCS.Projects(client);
// Get a list of Projects for this user
var projects = new GenericViewSet <Project>(tokens, user.host, "/api/project/").List();
Console.Write($"Got projects: {JsonConvert.SerializeObject(projects)}");
Assert.IsNotEmpty(projects, "Got empty project list");
}
public static Task CreateIndependenceActionTask(
AuthTokens tokens,
string url,
string path,
string parentId,
string dependentOn,
BaseMesh meshData,
bool create
)
{
var actionTask = new GenericViewSet <Task>(
tokens,
url,
path
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", "Actions" },
{ "parent", parentId },
{ "dependent_on", dependentOn }
},
new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "pipelines.pipeline" },
{ "commands", new List <string>
{
"magpy_copytree",
"write_mesh"
} },
{ "src", "foam" },
{ "dst", $"independence/mesh_{meshData.CellSize}/foam" },
{ "base_mesh", meshData },
{ "snappyhex_mesh", null }
}
}
},
create
);
return(actionTask);
}
public static Dictionary <string, object> Create(
string inputJson,
byte[] geometryFile
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
var solution = inputData.CFDSolution;
if (parentTask == null)
{
throw new System.Exception("Cannot upload a case without a parent task.");
}
if (project == null)
{
throw new System.Exception("Cannot upload a case without a project.");
}
// Upload File to parent task
new GenericViewSet <Dictionary <string, object> >(
tokens,
$"{inputData.Url}/api/task/{parentTask.UID}/file/foam/constant/triSurface/cfdGeom.stl"
).Update(
null,
new Dictionary <string, object>
{
{ "file", geometryFile }
}
);
// Tasks to Handle MagPy Celery Actions
// First Action to create Mesh Files
var actionTask = new GenericViewSet <Task>(
tokens,
$"{inputData.Url}/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object> {
{ "name", "Actions" },
{ "parent", parentTask.UID }
},
new Dictionary <string, object> {
{ "config", new Dictionary <string, object> {
{ "task_type", "magpy" },
{ "cmd", "cfd.io.tasks.write_mesh" },
{ "base_mesh", inputData.Mesh.BaseMesh },
{ "snappyhex_mesh", inputData.Mesh.SnappyHexMesh },
} }
},
true
);
// Then Action Task to create CFD files
new GenericViewSet <Task>(
tokens,
$"{inputData.Url}/api/project/{project.UID}/task/"
).Update(
actionTask.UID,
new Dictionary <string, object> {
{ "name", "Actions" },
{ "parent", parentTask.UID },
{ "status", "pending" },
{ "config", new Dictionary <string, object> {
{ "task_type", "magpy" },
{ "cmd", "cfd.io.tasks.write_solution" },
{ "solution", inputData.CFDSolution }
} }
}
);
// Task to Handle Meshing
var meshTask = new GenericViewSet <Task>(
tokens,
$"{inputData.Url}/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object> {
{ "name", "Mesh" },
{ "parent", parentTask.UID },
{ "dependent_on", actionTask.UID }
},
new Dictionary <string, object> {
{ "config", new Dictionary <string, object> {
{ "task_type", "cfd" },
{ "cmd", "pipeline" },
{ "commands", new List <string>
{
"blockMesh",
"snappyHesMesh -overwrite",
"reconstructParMesh -constant -mergeTol 1e-6",
"!checkMesh -writeSets vtk"
} },
{ "cpus", solution.CPUs },
} }
},
true
);
// Task to Handle CFD
Dictionary <string, object> createParams;
if (solution.CaseType.ToLower() == "virtualwindtunnel")
{
createParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "wind_tunnel" },
{ "commands", solution.Angles },
{ "cpus", solution.CPUs },
{ "iterations", solution.Iterations }
}
}
};
}
else
{
createParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "pipeline" },
{
"commands", new List <string>
{
solution.Solver,
"reconstructPar -skipZero"
}
},
{ "cpus", solution.CPUs },
{ "iterations", solution.Iterations }
}
}
};
}
var cfdTask = new GenericViewSet <Task>(
tokens,
$"{inputData.Url}/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object> {
{ "name", solution.CaseType },
{ "parent", parentTask.UID },
{ "dependent_on", meshTask.UID }
},
createParams,
true
);
List <string> tasks = new List <string> {
actionTask.ToJson(),
meshTask.ToJson(),
cfdTask.ToJson()
};
return(new Dictionary <string, object>
{
{ "out", tasks }
});
}
public static string GetOrCreate(
string inputJson,
string projectName,
int?projectNumber,
string taskName,
string overrides,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
// Unpack to an AuthToken instances
var tokens = inputData.Auth;
var overrideDict = overrides != null
? JsonConvert.DeserializeObject <Dictionary <string, object> >(overrides)
: new Dictionary <string, object>();
var queryParams = new Dictionary <string, object>
{
{ "name", projectName },
};
if (projectNumber != null)
{
queryParams.Add("number", projectNumber);
}
if (overrideDict.ContainsKey("company"))
{
queryParams.Add("company", overrideDict["company"]);
}
// Get a list of Projects for this user
var project = new GenericViewSet <Project>(
tokens,
inputData.Url,
"/api/project/"
).GetOrCreate(
queryParams,
null,
create
);
// We won't get here unless the last getting of Project succeeded
// Create the task if the Project succeeded
if (project.ErrorMessages != null)
{
throw new Exception(project.ErrorMessages.First());
}
inputData.Project = project;
var parentTask = Tasks.Utils.CreateParent(tokens, inputData.Url, $"/api/project/{project.UID}/task/", taskName,
overrideDict, create);
inputData.Task = parentTask;
if (overrideDict.ContainsKey("nest_with"))
{
var nestedParent = Tasks.Utils.CreateParent(tokens, inputData.Url, $"/api/project/{project.UID}/task/",
(string)overrideDict["nest_with"],
new Dictionary <string, object> {
{ "parent", parentTask.UID }
}, create);
inputData.Task = nestedParent;
}
return(inputData.ToJson());
}
public static List <Task> CreateMeshIndependenceProbeTask(
Inputs inputData,
List <int> cpus,
List <Dictionary <string, object> > sampleSets,
List <string> fields,
Dictionary <string, object> overrides,
bool create
)
{
var tokens = inputData.Auth;
var subTasks = inputData.SubTasks;
var parentTask = inputData.Task;
var projectId = inputData.Project.UID;
var url = inputData.Url;
var tasks = new List <Task>();
if (overrides == null)
{
overrides = new Dictionary <string, object> {
{ "set_dir", "/data/VWT" }
};
}
else
{
overrides.Add("set_dir", "VWT");
}
// Get Cell Size parent tasks
var meshIndependenceParent = Tasks.Utils.GetDependentTask(subTasks, "Mesh Independence Study",
inputData.Url, tokens, parentTask.UID);
var cellSizes = Tasks.Mesh.GetBaseCellSizes(inputData.Mesh, inputData.CFDSolution.Overrides);
var cellSizeNames = cellSizes.Select(size => $"Cell Size {size}").ToList();
var cellSizeTasks = Tasks.Utils.GetDependentTask(subTasks, cellSizeNames,
inputData.Url, tokens, meshIndependenceParent.UID);
var probeTasks = new List <string>();
// Get simpleCase tasks
var caseDirs = new List <string>();
foreach (var cellSizeTask in cellSizeTasks)
{
var simulationTask = Tasks.Utils.GetDependentTask(subTasks, "SimpleCase",
inputData.Url, tokens, cellSizeTask.UID);
if (simulationTask.Config == null)
{
simulationTask = new GenericViewSet <Task>(tokens,
url,
"/api/task/").Retrieve(simulationTask.UID);
}
var caseDir = (string)simulationTask.Config["case_dir"];
caseDirs.Add($"/data/{caseDir}");
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Probe" },
{ "parent", cellSizeTask.UID },
{ "dependent_on", simulationTask.UID }
};
var probeTask = CreateProbeTask(tokens, url, projectId, taskQueryParams, caseDir, cpus, sampleSets,
fields, overrides, "postProcess -func internalCloud -latestTime", create);
tasks.Add(probeTask);
probeTasks.Add(probeTask.UID);
}
// Create probe task for each
// Create statistics tasks
var statisticsTask = CreateProbeStatisticsTask(tokens, url, projectId, meshIndependenceParent.UID, probeTasks, caseDirs, cpus,
sampleSets.Select(sampleSet => (string)sampleSet["name"]).ToList(), fields, overrides, create);
tasks.Add(statisticsTask);
return(tasks);
}
public static bool Download(
string inputJson,
string downloadPath,
string localPath,
string overrides
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var overrideDict = JsonConvert.DeserializeObject <Dictionary <string, List <string> > >(overrides);
if (parentTask?.UID == null)
{
throw new Exception("Cannot download content without a parent task.");
}
if (!Directory.Exists(localPath))
{
Directory.CreateDirectory(localPath);
}
var localFiles = Directory.EnumerateFiles(localPath, "*", SearchOption.AllDirectories)
.Select(file => file.Remove(0, localPath.Length + 1)).ToList();
foreach (var fileWin in localFiles)
{
var fileUnix = fileWin.Replace('\\', '/');
if (StringCache.getCache(fileUnix) == null)
{
StringCache.setCache(fileUnix, GetMD5(Path.Combine(localPath, fileWin)));
}
}
var queryParams = new Dictionary <string, object> {
{ "filepath", downloadPath }, { "hash", true }
};
if (overrideDict != null && overrideDict.ContainsKey("exclude"))
{
queryParams.Add("exclude", string.Join(",", overrideDict["exclude"]));
}
if (overrideDict != null && overrideDict.ContainsKey("include"))
{
queryParams.Add("pattern", string.Join(",", overrideDict["include"]));
}
var serverFiles = new GenericViewSet <TaskFile>(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/"
).List(queryParams);
if (serverFiles.Count == 0)
{
return(false);
}
foreach (var serverFile in serverFiles)
{
// fileName is Unix path
var filePathUnix = serverFile.File;
var fileHash = serverFile.Hash;
if (!filePathUnix.StartsWith(downloadPath))
{
continue;
}
var filePathWin = filePathUnix == downloadPath?filePathUnix.Split('/').Last() : filePathUnix.Remove(0, downloadPath.Length + 1).Replace('/', '\\');
var localFilePath = Path.Combine(localPath, filePathWin);
var localFileDirectory =
string.Join("\\", localFilePath.Split('\\').Take(localFilePath.Split('\\').Length - 1));
if (!Directory.Exists(localFileDirectory))
{
Directory.CreateDirectory(localFileDirectory);
}
if (!localFiles.Contains(filePathWin))
{
var response = new GenericViewSet <string>(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/"
).Retrieve(filePathUnix, localFileDirectory, new Dictionary <string, object> {
{ "download", true }
});
StringCache.setCache(filePathUnix, GetMD5(localFilePath));
Thread.Sleep(100);
}
else if (fileHash != StringCache.getCache(filePathUnix.Remove(0, downloadPath.Length + 1)))
{
var response = new GenericViewSet <string>(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/"
).Retrieve(filePathUnix, localFileDirectory, new Dictionary <string, object> {
{ "download", true }
});
StringCache.setCache(filePathUnix, GetMD5(localFilePath));
Thread.Sleep(100);
}
}
return(true);
}
public static Dictionary <string, double> GetTaskEstimates(string inputJson)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var solution = inputData.CFDSolution;
if (solution == null)
{
return(new Dictionary <string, double>());
}
var cells = inputData.Mesh.CellEstimate;
var iterations = solution.Iterations["init"];
var nCPUs = 1;
solution.CPUs.ForEach(cpu => nCPUs *= cpu);
var meshEstimate = new GenericViewSet <TaskEstimate>(
tokens,
inputData.Url,
$"/api/task/estimation/"
).Create(
new Dictionary <string, object>
{
{ "cells", cells },
{ "cpus", nCPUs },
{ "task_type", "mesh" }
}
);
var totalTime = meshEstimate.Time;
var totalCost = meshEstimate.Cost;
if (solution.CaseType == "VirtualWindTunnel")
{
var angleEstimate = new GenericViewSet <TaskEstimate>(
tokens,
inputData.Url,
$"/api/task/estimation/"
).Create(
new Dictionary <string, object>
{
{ "cells", cells },
{ "cpus", nCPUs },
{ "task_type", "vwt_angle" },
{ "iterations", iterations }
}
);
var prepareEstimate = new GenericViewSet <TaskEstimate>(
tokens,
inputData.Url,
$"/api/task/estimation/"
).Create(
new Dictionary <string, object>
{
{ "cells", cells },
{ "cpus", nCPUs },
{ "task_type", "prepare" },
{ "iterations", iterations }
}
);
totalTime += prepareEstimate.Time + angleEstimate.Time;
totalCost += prepareEstimate.Cost + angleEstimate.Cost * solution.Angles.Count;
;
}
return(new Dictionary <string, double>
{
{ "cost", totalCost },
{ "time", totalTime },
{ "cells", cells }
});
}
public static string CreateRadiance(string inputJson, string folder, bool compute)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
if (parentTask == null)
{
return(null);
//throw new System.Exception("Cannot upload a case without a parent task.");
}
if (project == null)
{
return(null);
//throw new System.Exception("Cannot upload a case without a project.");
}
if (compute)
{
var files = Directory.GetFiles(folder);
if (!files.Any(file => file.ToLower().EndsWith(".rad")))
{
throw new Exception("Case folder should contain an .rad file");
}
foreach (var file in files)
{
var fileInfo = new FileInfo(file);
var text = File.ReadAllBytes(file);
var response = new GenericViewSet <Dictionary <string, object> >(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/foam/{fileInfo.Name}"
).Update(
null,
new Dictionary <string, object>
{
{ "file", text }
}
);
if (response.ContainsKey("error_messages"))
{
throw new Exception(
$"Got the following error, while trying to upload: {file}: {response["error_messages"]}");
}
Thread.Sleep(100);
}
}
var cpus = GetRadianceCPUs(folder);
var createParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", "run_honeybee_radiance" },
{ "cpus", cpus }
}
},
{ "status", "pending" }
};
var radianceTask = new GenericViewSet <Task>(
tokens,
inputData.Url,
$"/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", "Radiance" },
{ "parent", parentTask.UID },
},
createParams,
compute
);
var tasks = new List <Task>
{
radianceTask
};
inputData.SubTasks = tasks;
return(inputData.ToJson());
}
public static string CreateEnergyPlus(string inputJson, string folder, bool compute)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
if (parentTask == null)
{
return(null);
//throw new System.Exception("Cannot upload a case without a parent task.");
}
if (project == null)
{
return(null);
//throw new System.Exception("Cannot upload a case without a project.");
}
if (compute)
{
var files = Directory.GetFiles(folder);
if (!files.Any(file => file.ToLower().EndsWith(".idf")))
{
throw new Exception($"Case folder should contain an idf");
}
if (!files.Any(file => file.ToLower().EndsWith(".epw")))
{
throw new Exception($"Case folder should contain an epw");
}
foreach (var file in files)
{
var fileInfo = new FileInfo(file);
var text = File.ReadAllBytes(file);
var response = new GenericViewSet <Dictionary <string, object> >(
tokens,
inputData.Url,
$"/api/task/{parentTask.UID}/file/foam/${fileInfo.Name}"
).Update(
null,
new Dictionary <string, object>
{
{ "file", text }
}
);
}
}
var createParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "energyplus" },
{ "cmd", "run_honeybee_energyplus" },
{ "cpus", new List <int> {
1, 1, 1
} }
}
},
{ "status", "pending" }
};
var energyTask = new GenericViewSet <Task>(
tokens,
inputData.Url,
$"/api/project/{project.UID}/task/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", "EnergyPlus" },
{ "parent", parentTask.UID },
},
createParams,
compute
);
var tasks = new List <Task>
{
energyTask
};
inputData.SubTasks = tasks;
return(inputData.ToJson());
}
/// <summary>
/// Create a Mesh Task
/// </summary>
public static Task CreateMeshTask(
AuthTokens tokens,
string url,
string projectId,
string taskId,
string actionTaskId,
List <int> cpus,
bool includeSetSet,
Dictionary <string, object> overrides,
bool create
)
{
if (overrides != null && overrides.ContainsKey("keep_mesh") && (bool)overrides["keep_mesh"])
{
create = false;
}
var nCPUs = 1;
cpus.ForEach(cpu => nCPUs *= cpu);
var commands = new List <string>
{
"remove_processor_directories",
"blockMesh",
"snappyHexMesh -overwrite"
};
if (nCPUs > 1)
{
commands.Add("reconstructParMesh -constant -mergeTol 1e-6");
}
commands.Add("!checkMesh -writeSets vtk");
commands.Add("foamToSurface -constant surfaceMesh.obj");
if (includeSetSet)
{
commands.Add("!setSet -batch zones.setSet");
}
var config = new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "pipeline" },
{ "commands", commands },
{ "cpus", cpus },
};
if (overrides != null && overrides.ContainsKey("webhook"))
{
config.Add("webhook", overrides["webhook"]);
}
try
{
var meshTask = new GenericViewSet <Task>(
tokens,
url,
$"/api/project/{projectId}/task/"
).GetOrCreate(
new Dictionary <string, object>
{
{ "name", "Mesh" },
{ "parent", taskId },
{ "dependent_on", actionTaskId }
},
new Dictionary <string, object>
{
{
"config", config
}
},
create
);
return(meshTask);
}
catch (NoObjectFoundException error)
{
if (overrides != null && overrides.ContainsKey("keep_mesh") && (bool)overrides["keep_mesh"])
{
// if keep_mesh is in the overrides then we most likely are in the situation of a
// mesh independence study and the user want to reuse the mesh from the study. There will therefore not be any Mesh task to find.
return(null);
}
throw new NoObjectFoundException(error.Message);
}
}
public static Task CreateParent(
AuthTokens tokens,
string url,
string path,
string taskName,
Dictionary <string, object> overrides,
bool create
)
{
var taskQueryParams = new Dictionary <string, object>
{
{ "name", taskName }
};
if (overrides.ContainsKey("parent"))
{
taskQueryParams.Add("parent", overrides["parent"]);
}
var config = new Dictionary <string, object>
{
{
"task_type", "parent"
},
{ "case_dir", "foam" }
};
if (overrides.ContainsKey("case_dir"))
{
config["case_dir"] = overrides["case_dir"];
config["show_meta_data"] = overrides["show_meta_data"];
}
var taskCreateParams = new Dictionary <string, object>
{
{
"config", config
}
};
if (overrides.ContainsKey("copy_from"))
{
taskCreateParams.Add("copy_from", overrides["copy_from"]);
}
if (overrides.ContainsKey("comment"))
{
taskCreateParams.Add("comment", overrides["comment"]);
}
var task = new GenericViewSet <Task>(
tokens,
url,
path
).GetOrCreate(
taskQueryParams,
taskCreateParams,
create
);
if (task.ErrorMessages != null)
{
if (task.ErrorMessages.First() == "No object found.")
{
throw new NoObjectFoundException($"No task with name: {taskName} found");
}
throw new Exception(task.ErrorMessages.First());
}
return(task);
}
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);
}
