public void SubmitToComputing()
{
const string method = nameof(SubmitToComputing);
//FillInBlanks(); // TODO
var startTime = DateTime.Now;
var sw = new Stopwatch();
sw.Start();
var logger = new Logger()
.SetPrintLevel(Logger.LogLevel.Custom)
.SetPrintFilter(new List <Logger.EventType> {
Logger.EventType.Inspect, Logger.EventType.Warning
});
logger.Log(Logger.EventType.Info, $"{Scope(method)}: Logger initialized.");
Compute(mainPanel.preset, logger, null, Settings.Flags.WriteFactors);
if (Settings.flags.writeLogs)
{
var path = Path.Combine(Directory.GetCurrentDirectory(), Settings.DefaultValues.LogFolderName,
$"{DateTime.Now:yyyy-MM-ddTHH.mm.ss} Log.txt");
logger.WriteToFile(path);
}
logger.Log(Logger.EventType.Info, $"{Scope(method)}: Shader adapter executed.");
sw.Stop();
SetStatusMessage($"Last job executed at {startTime:T}.\nTime elapsed: {sw.Elapsed:g}.");
}
protected ShaderAdapter(
ComputeShader shader,
Preset preset,
bool writeFactors,
Logger logger = null,
double[] angles = null,
PerformanceReport performanceReport = null
)
{
this.shader = shader;
properties = preset.properties;
metadata = preset.metadata;
this.writeFactors = writeFactors;
if (logger != null)
{
SetLogger(logger);
}
if (performanceReport == null)
{
var info = PerformanceReport.InputInfo.FromPreset(preset);
stopwatch = new PerformanceReport(info);
}
else
{
stopwatch = performanceReport;
}
if (angles != null)
{
this.angles = angles;
}
stopwatch.Start(PerformanceReport.TimeInterval.Category.Total);
InitSharedFields();
}
public PlaneModeAdapter(
ComputeShader shader,
Preset preset,
bool writeFactors,
Logger customLogger,
PerformanceReport performanceReport
) : base(shader, preset, writeFactors, customLogger, null, performanceReport)
{
if (logger == null)
{
SetLogger(customLogger);
}
logger.Log(Logger.EventType.Class, $"{nameof(PlaneModeAdapter)} created.");
InitializeOtherFields();
}
public IntegratedModeAdapter(
ComputeShader shader,
Preset preset,
bool writeFactors,
Logger customLogger,
double[] angles,
PerformanceReport performanceReport
) : base(shader, preset, writeFactors, customLogger, angles, performanceReport)
{
if (logger == null)
{
SetLogger(customLogger);
}
logger.Log(Logger.EventType.Class, $"{CLASS_NAME} created.");
InitializeOtherFields();
}
public void Compute(Preset preset, Logger logger, PerformanceReport report, bool write = false,
double[] angles = null)
{
const string method = nameof(Compute);
logger.Log(Logger.EventType.Info, $"{Scope(method)}: Shader adapter built." +
$" preset set to = {mainPanel.preset}");
_shaderAdapter = _builder
.SetLogger(logger)
.SetWriteFactors(write)
.SetPerformanceReport(report)
.SetProperties(preset)
.SetAngles(angles)
.AutoSetShader()
.Build();
_shaderAdapter.SetStatus(ref status);
_shaderAdapter.Execute();
}
private void RunABTests()
{
const string method = nameof(RunABTests);
Debug.Log($"{Scope(method)}: started.");
var logger = new Logger()
.SetPrintFilter(new List <Logger.EventType> {
Logger.EventType.Warning, Logger.EventType.Test
})
.SetWriteFilter(new List <Logger.EventType> {
Logger.EventType.Warning, Logger.EventType.Test
});
var logPath = Path.Combine(Directory.GetCurrentDirectory(), "Logs", "A-B Test log.txt");
logger.Log(Logger.EventType.Info, $"{Scope(method)}: Logger initialized.");
// read presets
var testPresetNames = new List <string>
{
"ref",
"ref ray"
};
var testPresets = testPresetNames
.Select(s => Path.Combine(_saveDir, s + Settings.DefaultValues.SerializedExtension))
.Select(ReadPreset)
.ToList();
var modeList = new List <AbsorptionProperties.Mode>
{
AbsorptionProperties.Mode.Point,
AbsorptionProperties.Mode.Area,
AbsorptionProperties.Mode.Integrated
};
GenerateTestData(logger, testPresets, modeList);
CompareTestData(logger, testPresets, modeList);
SetStatusMessage("A/B-Test completed.");
logger.AppendToFile(logPath);
}
private void GenerateTestData(Logger logger, List <Preset> presets, List <AbsorptionProperties.Mode> modes)
{
const string method = nameof(GenerateTestData);
// Backup and modify flag.
var clippingBackup = Settings.flags.clipAngles;
Settings.flags.clipAngles = false;
// generate and save test dataset.
var step = 0;
foreach (var mode in modes)
{
foreach (var preset in presets)
{
preset.properties.absorption.mode = mode;
preset.metadata.pathOutputData = "B";
_shaderAdapter = _builder
.SetLogger(logger)
.SetWriteFactors(true)
.SetProperties(preset)
.AutoSetShader()
.Build()
;
_shaderAdapter.SetStatus(ref status);
++step;
logger.Log(Logger.EventType.Test,
$"{Scope(method)}: " +
$"Shader adapter built. ({step}/{presets.Count*modes.Count})" +
$" preset set to = {preset.metadata.saveName}");
_shaderAdapter.Execute();
logger.Log(Logger.EventType.Test,
$"{Scope(method)}: Shader adapter executed. ({step}/{presets.Count * modes.Count})");
_shaderAdapter.SetStatusMessage(
$"{Scope(method)}: Step {step}/6: preset {preset.metadata.saveName}, {mode}");
}
}
Settings.flags.clipAngles = clippingBackup;
}
/// <summary>
/// Run benchmark in DataHandler.
/// </summary>
/// <param name="write">Toggle to write the computation results to disk.</param>
public Benchmark Run(bool write = true)
{
if (!Ready())
{
return(this);
}
var clipBackup = Settings.flags.clipAngles;
Settings.flags.clipAngles = false;
_reports = new List <PerformanceReport>();
var logger = new Logger()
.SetPrintFilter(new List <Logger.EventType> {
Logger.EventType.Warning, Logger.EventType.Performance
})
.SetWriteFilter(new List <Logger.EventType> {
Logger.EventType.Warning
});
foreach (var inputInfo in _inputInfos)
{
// set preset fields
Adjust(inputInfo);
var angles = MathTools.LinSpace1D(0.0, 180.0, inputInfo.n, false);
var report = new PerformanceReport(inputInfo);
_dataHandler.Compute(_preset, logger, report, write, angles);
_reports.Add(_dataHandler.GetPerformanceReport());
logger.Log(Logger.EventType.Performance, _dataHandler.GetPerformanceReport().ToString());
}
_done = true;
Settings.flags.clipAngles = clipBackup;
return(this);
}
private void CompareTestData(Logger logger, List <Preset> presets, List <AbsorptionProperties.Mode> modes)
{
// read datasets, compare B to A, generate report.
foreach (var preset in presets)
{
var nrAngles = Parser.ImportAngles(Path.Combine(Directory.GetCurrentDirectory(),
Settings.DefaultValues.InputFolderName, preset.properties.angle.pathToAngleFile + ".txt")).Length;
foreach (var mode in modes)
{
var folderBottom = preset.metadata.saveName ?? "";
var outputDir = Path.Combine(Directory.GetCurrentDirectory(),
Settings.DefaultValues.OutputFolderName);
var dirA = Path.Combine(outputDir, "A", folderBottom);
var dirB = Path.Combine(outputDir, "B", folderBottom);
List <Vector3> a;
List <Vector3> b;
preset.properties.absorption.mode = mode;
preset.metadata.pathOutputData = "A";
var fileNameA = preset.properties.FilenameFormatter(nrAngles);
preset.metadata.pathOutputData = "B";
var fileNameB = preset.properties.FilenameFormatter(nrAngles);
if (mode == AbsorptionProperties.Mode.Area)
{
var a2D = Parser.ReadArray(Path.Combine(dirA, fileNameA), false, false, reverse: true);
var b2D = Parser.ReadArray(Path.Combine(dirB, fileNameB), false, false, reverse: true);
a = Enumerable.Range(0, a2D.GetLength(0))
.Select(i => Enumerable.Range(0, a2D.GetLength(1))
.Select(j => a2D[i, j]))
.SelectMany(v => v)
.ToList();
b = Enumerable.Range(0, b2D.GetLength(0))
.Select(i => Enumerable.Range(0, b2D.GetLength(1))
.Select(j => b2D[i, j]))
.SelectMany(v => v)
.ToList();
}
else
{
a = Parser.ReadTableVector(Path.Combine(dirA, fileNameA), true, true).ToList();
b = Parser.ReadTableVector(Path.Combine(dirB, fileNameB), true, true).ToList();
}
Vector3 Subtract(Vector3 v1, Vector3 v2)
{
return(new Vector3(
float.IsInfinity(v1.x) && float.IsInfinity(v2.x) ? 0f : v1.x - v2.x,
float.IsInfinity(v1.y) && float.IsInfinity(v2.y) ? 0f : v1.y - v2.y,
float.IsInfinity(v1.z) && float.IsInfinity(v2.z) ? 0f : v1.z - v2.z
));
}
var diff = Enumerable.Range(0, a.Count)
.Select(i => Subtract(a[i], b[i]))
.ToList();
var min = new Vector3(
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.x).Min(),
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.y).Min(),
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.z).Min()
);
var max = new Vector3(
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.x).Max(),
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.y).Max(),
diff.AsParallel().Where(v => v != Vector3.positiveInfinity).Select(v => v.z).Max()
);
var mean = diff.AsParallel()
.Where(v => v != Vector3.positiveInfinity)
.Aggregate((sum, v) => sum + v) /
diff.Count(v => v != Vector3.positiveInfinity);
var var = diff.AsParallel()
.Where(v => v != Vector3.positiveInfinity)
.Select(v => v - mean)
.Select(v => Vector3.Scale(v, v))
.Aggregate((variance, v) => variance + v) /
diff.Count(v => v != Vector3.positiveInfinity);
logger.Log(Logger.EventType.Test,
$"{Scope(nameof(CompareTestData))}: " +
$"Test result (preset=\"{preset.metadata.saveName}\", mode={mode}): " +
$"min={min:G}, max={max:G}, mean={mean:G}, var={var:G}"
);
}
}
}
protected void SetLogger(Logger newLogger)
{
logger = newLogger;
}
