public static Task CreateProbeStatisticsTask(
AuthTokens tokens,
string url,
string projectId,
string parentTaskId,
List <string> dependentOns,
List <string> caseDirs,
List <int> cpus,
List <string> sampleSets,
List <string> fields,
Dictionary <string, object> overrides,
bool create
)
{
var config = new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "compute_mesh_independence_result" },
{ "case_dirs", caseDirs },
{ "case_dir", "independence" },
{ "cpus", cpus },
{ "sets", sampleSets },
{ "fields", fields },
};
if (overrides != null)
{
config.Add("overrides", overrides);
}
var createParams = new Dictionary <string, object>
{
{
"config", config
},
{
"dependent_on", dependentOns
}
};
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Probe Statistics" },
{ "parent", parentTaskId },
{ "project", projectId }
};
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
"/api/task/",
taskQueryParams,
createParams,
create
);
Logger.Info($"Created probe task: {task.UID}");
return(task);
}
public static Task CreateProbeTask(
AuthTokens tokens,
string url,
string projectId,
Dictionary <string, object> taskQueryParams,
string caseDir,
List <int> cpus,
List <Dictionary <string, object> > sampleSets,
List <string> fields,
Dictionary <string, object> overrides,
string probeCommand = "postProcess -func internalCloud",
bool create = false
)
{
var commands = new List <string> {
"write_sample_set"
};
var nCPUs = 1;
cpus.ForEach(cpu => nCPUs *= cpu);
commands.Add(nCPUs > 1 ? $"!{probeCommand}" : probeCommand);
var config = new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "pipeline" },
{ "commands", commands },
{ "case_dir", caseDir },
{ "cpus", cpus },
{ "sets", sampleSets },
{ "fields", fields },
};
if (overrides != null)
{
config.Add("overrides", overrides);
}
var createParams = new Dictionary <string, object>
{
{
"config", config
}
};
taskQueryParams.Add("project", projectId);
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
taskQueryParams,
createParams,
create
);
Logger.Info($"Created probe task: {task.UID}");
return(task);
}
public static Task CreateRadianceTask(
AuthTokens tokens,
string url,
Task parentTask,
Task dependentOnTask,
Project project,
types.RadiationSolution solution,
string caseDir,
bool create
)
{
var taskConfig = new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", solution.Method },
{ "case_type", solution.CaseType },
{ "cpus", solution.CPUs },
{ "case_dir", caseDir },
{ "probes", solution.Probes },
};
if (solution.Overrides != null)
{
taskConfig.Add("overrides", solution.Overrides.ToDict());
}
if (!string.IsNullOrEmpty(solution.EPWFile))
{
taskConfig.Add("epw_file", Path.GetFileName(solution.EPWFile));
}
var createParams = new Dictionary <string, object>
{
{
"config", taskConfig
}
};
var radianceTask = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(solution.Method) },
{ "parent", parentTask.UID },
{ "dependent_on", dependentOnTask.UID },
{ "project", project.UID }
},
createParams,
create
);
if (radianceTask.ErrorMessages != null && radianceTask.ErrorMessages.Count > 0)
{
throw new Exception(radianceTask.ErrorMessages.First());
}
return(radianceTask);
}
public static Task CreateRadiationProbeTask(
AuthTokens tokens,
string url,
string projectId,
Dictionary <string, object> taskQueryParams,
string caseDir,
List <Dictionary <string, object> > sampleSets,
bool create
)
{
var config = new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "radiance.io.tasks.write_radiation_samples_set" },
{ "case_dir", caseDir },
{ "sets", sampleSets },
};
var createParams = new Dictionary <string, object>
{
{ "config", config },
{ "status", "pending" }
};
taskQueryParams.Add("project", projectId);
var task = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
taskQueryParams,
createParams,
create
);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages.First());
}
return(task);
}
public static string Create(
string inputJson,
string overrides,
string preset,
List <int> cpus,
string caseDir,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var project = inputData.Project;
var solution = inputData.RadiationSolution;
var subTasks = inputData.SubTasks;
var daylightTask = GetDaylightTask(subTasks, Utils.SnakeCaseToHumanCase(solution.Method));
var _overrides = JsonConvert.DeserializeObject <Dictionary <string, object> >(overrides);
if (parentTask == null)
{
return(null);
}
if (project == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(preset) },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (daylightTask != null)
{
taskQueryParams.Add("dependent_on", daylightTask.UID);
}
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", $"{preset}" },
{ "overrides", _overrides },
{ "cpus", cpus },
{ "case_dir", caseDir },
{ "result_names", solution.Probes.Keys }
}
}
};
// First Action to create Mesh Files
var metricTask = TaskViews.GetCreateOrUpdateTask(
tokens,
inputData.Url,
$"/api/task/",
taskQueryParams,
taskCreateParams,
create
);
if (metricTask.ErrorMessages != null && metricTask.ErrorMessages.Count > 0)
{
throw new Exception(metricTask.ErrorMessages.First());
}
inputData.SubTasks.Add(metricTask);
return(inputData.ToJson());
}
public static string CreateComfortTask(
string inputJson,
string epwFile,
string method,
List <string> probes,
List <string> thresholds,
List <int> cpus,
string dependentOn = "Probe",
bool create = false)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", Utils.SnakeCaseToHumanCase(method) },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
if (!File.Exists(epwFile))
{
throw new Exception("A .epw file is needed to proceed!");
}
var epwName = Path.GetFileName(epwFile);
if (create)
{
Tasks.Upload.UploadEPWFile(tokens, inputData.Url, parentTask.UID, epwFile);
}
var _thresholds = thresholds.Select(threshold => new Thresholds.ComfortThreshold().FromJson(threshold))
.ToList();
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "radiance" },
{ "cmd", "outdoor_comfort" },
{ "case_dir", "results" },
{ "epw_file", epwName },
{ "probes", probes },
{ "thresholds", _thresholds },
{ "cpus", cpus },
{ "comfort_index", method },
{ "wind_dir", "urbanComfort" }
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Outdoor Comfort task: {task.UID}");
return(inputData.ToJson());
}
public static string CreatePressureCoefficientTask(
string inputJson,
List <string> probeNames,
List <int> cpus,
string dependentOn,
string overrides,
bool create
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
var overrideDict = JsonConvert.DeserializeObject <Dictionary <string, object> >(overrides);
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Pressure Coefficient" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "calculate_pressure_coefficients" },
{ "case_dir", "VWT" },
{ "probes", probeNames },
{ "cpus", cpus },
{ "overrides", overrideDict }
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Pressure Coefficient task: {task.UID}");
return(inputData.ToJson());
}
public static Task CreateRadianceActionTask(
AuthTokens tokens,
string url,
Task parentTask,
Task probeTask,
Project project,
types.RadiationSolution solution,
string caseDir,
bool create
)
{
var actionTaskQueryParams = new Dictionary <string, object>
{
{ "name", "Actions" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (probeTask != null)
{
actionTaskQueryParams.Add("dependent_on", probeTask.UID);
}
var actionTaskConfig = new Dictionary <string, object>
{
{ "task_type", "magpy" },
{ "cmd", "radiance.io.tasks.write_rad" },
{ "materials", solution.Materials.Select(material => material.ToDict()).ToList() },
{ "case_dir", caseDir },
{ "method", solution.Method },
};
if (solution.Overrides != null && solution.Overrides.ReinhartDivisions > 1)
{
actionTaskConfig.Add("reinhart_divisions", solution.Overrides.ReinhartDivisions);
}
// Tasks to Handle MagPy Celery Actions
// First Action to create Mesh Files
var actionTask = TaskViews.GetCreateOrUpdateTask(
tokens,
url,
$"/api/task/",
actionTaskQueryParams,
new Dictionary <string, object>
{
{
"config", actionTaskConfig
}
},
create
);
if (actionTask.ErrorMessages == null || actionTask.ErrorMessages.Count <= 0)
{
return(actionTask);
}
if (actionTask.ErrorMessages.First() == "No object found.")
{
return(null);
}
throw new Exception(actionTask.ErrorMessages.First());
}
public static string ComputeWindThresholds(
string inputJson,
string epwFile,
List <string> patches,
List <string> thresholds,
List <int> cpus,
string dependentOn = "Probe",
bool create = false
)
{
var inputData = new Inputs().FromJson(inputJson);
var tokens = inputData.Auth;
var parentTask = inputData.Task;
var subTasks = inputData.SubTasks;
var postProcessTask =
Tasks.Utils.GetDependentTask(subTasks, dependentOn, inputData.Url, tokens, parentTask.UID);
var project = inputData.Project;
if (parentTask?.UID == null)
{
return(null);
}
var taskQueryParams = new Dictionary <string, object>
{
{ "name", "Wind Thresholds" },
{ "parent", parentTask.UID },
{ "project", project.UID }
};
if (postProcessTask != null)
{
taskQueryParams.Add("dependent_on", postProcessTask.UID);
}
if (!File.Exists(epwFile))
{
throw new Exception("A .epw file is needed to proceed!");
}
if (create)
{
Tasks.Upload.UploadEPWFile(tokens, inputData.Url, parentTask.UID, epwFile);
}
var _thresholds = thresholds.Select(threshold => new Thresholds.WindThreshold().FromJson(threshold))
.ToList();
var epwName = Path.GetFileName(epwFile);
var taskCreateParams = new Dictionary <string, object>
{
{
"config", new Dictionary <string, object>
{
{ "task_type", "cfd" },
{ "cmd", "run_wind_thresholds" },
{ "case_dir", "VWT/" },
{ "epw_file", $"weather/{epwName}" },
{ "patches", patches },
{ "thresholds", _thresholds },
{ "set_foam_patch_fields", false },
{ "cpus", cpus },
}
}
};
var task = TaskViews.GetCreateOrUpdateTask(tokens, inputData.Url, "/api/task/", taskQueryParams,
taskCreateParams, create);
if (task.ErrorMessages != null)
{
throw new Exception(task.ErrorMessages[0]);
}
if (inputData.SubTasks != null)
{
inputData.SubTasks.Add(task);
}
else
{
inputData.SubTasks = new List <Task> {
task
};
}
Logger.Info($"Created Wind Threshold task: {task.UID}");
return(inputData.ToJson());
}