/// <summary>
/// Loads the inputs.
/// </summary>
/// <returns><c>true</c>, if inputs was loaded, <c>false</c> otherwise.</returns>
public bool LoadInputs()
{
bool success = false;
try
{
InputData = new Dictionary <string, IEnumerable <SensorReading> >();
foreach (var input in Inputs)
{
foreach (var inputFile in input.InputFiles)
{
// read in the sensor data
var sensorReadings = SensorReading.ReadSensorFile(inputFile.Value);
// verify input - only take records between the "start" and "quit" flags
var startRecord = sensorReadings.FirstOrDefault(x => x.Start);
if (startRecord != null)
{
sensorReadings = sensorReadings.Where(x => x.RecordNum >= startRecord.RecordNum).ToList();
}
var quitRecord = sensorReadings.FirstOrDefault(x => x.End);
if (quitRecord != null)
{
sensorReadings = sensorReadings.Where(x => x.RecordNum <= quitRecord.RecordNum).ToList();
}
// add data to collection using file name, not file path
InputData.Add(inputFile.Key, sensorReadings);
}
}
// run any initialization methods for selected modules
foreach (var summarizer in Summarizers)
{
SummarizerManager.GetSummarizer(summarizer).Initialize(InputData);
}
// confirm that everything worked
LogManager.Debug($"{InputData.Keys.Count} files processed.");
foreach (var key in InputData.Keys)
{
LogManager.Debug($"Input file: {key} ... contains {InputData[key].Count()} records.");
}
success = InputData.Any();
}
catch (Exception e)
{
LogManager.Error("Fatal error encountered while loading input data. Exiting program.", e, this);
}
return(success);
}
/// <summary>
/// Runs the analyzers.
/// </summary>
/// <returns><c>true</c>, if analyzers was run, <c>false</c> otherwise.</returns>
public bool RunAnalyzers()
{
if (!Analyzers.Any())
{
LogManager.Info("No analysis operations configured.", this);
return(true);
}
bool success = false;
if (Analyzers?.Count > 0 && InputData?.Keys?.Count >= 1)
{
var analyzedData = new Dictionary <string, IEnumerable <ICsvWritable> >();
foreach (var analyzerCommand in Analyzers)
{
// ---------------------------------------------------------
// Retrieve analysis operation details
// ---------------------------------------------------------
var analyzerName = analyzerCommand.Name;
var analyzer = AnalyzerManager.GetAnalyzer(analyzerName);
if (analyzer == null)
{
continue;
}
// Sanity checking ...
LogManager.Info($"Running analysis operation:\n\t{analyzer}", this);
// ---------------------------------------------------------
// Check to see if user requested a summary
// ---------------------------------------------------------
bool summaryRequested = Summarizers.Contains(analyzerName);
// ---------------------------------------------------------
// Group input data by original file name
// ---------------------------------------------------------
var consolidatedInputFiles =
Inputs.SelectMany(x => x.InputFiles.Select(y => y.Key)).ToList();
foreach (var origInputFile in consolidatedInputFiles)
{
var analysisDataByInputFile = new Dictionary <string, IEnumerable <ICsvWritable> >();
var analysisKeysByInputFile = InputData.Keys.Where(x => x.Contains(origInputFile));
foreach (var key in analysisKeysByInputFile)
{
// -------------------------------------------------
// Perform the actual analysis operation
// -------------------------------------------------
if (analyzerCommand.HasParameters &&
FilterManager.ContainsFilter(Filters, typeof(ThresholdCalibrationFilter)))
{
var calibData = CalibrationData[origInputFile];
analyzerCommand.Parameters =
ThresholdCalibrationFilter.CalibrateParameters
(analyzerCommand.Parameters, calibData);
}
// -------------------------------------------------
// Any required analyzer-specific prep
// -------------------------------------------------
if (analyzer is Analyzers.SciKitPrepAnalysis skpAnalyzer)
{
skpAnalyzer.CurrentInput = key;
}
else if (analyzer is Analyzers.SciKitEvalAnalysis skeAnalyzer)
{
skeAnalyzer.CurrentInput = key;
}
// -------------------------------------------------
var analysisResult =
analyzer.Analyze(InputData[key], analyzerCommand.Parameters);
analysisDataByInputFile[key] = analysisResult;
// -------------------------------------------------
// Dump output to file if necessary
// -------------------------------------------------
if (WriteOutputFile)
{
CsvFileWriter.WriteResultsToFile
(new string[] { OutputDirs.Analyzers, analyzerName },
key, analyzer.HeaderCsv, analysisResult);
}
// -------------------------------------------------
// If requested, summarize file-specific results
// -------------------------------------------------
if (summaryRequested)
{
ISummarizer summarizer =
SummarizerManager.GetSummarizer(analyzerName);
var summarizedValues =
summarizer.Summarize(analysisDataByInputFile);
if (WriteOutputFile)
{
CsvFileWriter.WriteSummaryToFile
(new string[] { OutputDirs.Summarizers, analyzerName },
$"{origInputFile}{Constants.BAT.DEFAULT_INPUT_FILE_EXT}",
summarizer.HeaderCsv, summarizedValues,
summarizer.FooterCsv, summarizer.FooterValues);
}
}
}
// consolidate the results by input file
var inputFileResults = analyzer.ConsolidateData(analysisDataByInputFile);
if (analyzedData.ContainsKey(origInputFile))
{
analyzedData[origInputFile] = inputFileResults;
}
else
{
analyzedData.Add(origInputFile, inputFileResults);
}
}
// -----------------------------------------------------
// If requested, aggregate all file-specific summaries
// into one high level file in root summarizer directory
// -----------------------------------------------------
if (summaryRequested)
{
ISummarizer summarizer = SummarizerManager.GetSummarizer(analyzerName);
var summarizedValues = summarizer.Summarize(analyzedData);
if (WriteOutputFile)
{
CsvFileWriter.WriteSummaryToFile
(new string[] { OutputDirs.Summarizers },
$"{analyzerName}Aggregate{Constants.BAT.DEFAULT_INPUT_FILE_EXT}",
summarizer.HeaderCsv, summarizedValues,
summarizer.FooterCsv, summarizer.FooterValues);
}
}
success = true;
}
// use different collection to maintain integrity of original input data
AnalysisData = analyzedData;
}
else
{
LogManager.Error("No input data to run analyzers on.", this);
}
return(success);
}
