protected override void Context()
{
base.Context();
_runOptions = new SensitivityAnalysisRunOptions();
_allEvents = new List <SensitivityAnalysisEvent>();
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisStartedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisStartedEvent>(0)));
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisTerminatedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisTerminatedEvent>(0)));
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisResultsUpdatedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisResultsUpdatedEvent>(0)));
_variationData = A.Fake <VariationData>();
_dataTable = new DataTable();
A.CallTo(() => _variationData.ToDataTable()).Returns(_dataTable);
A.CallTo(() => _sensitivityAnalysisVariationDataCreator.CreateForRun(_sensitivityAnalysis)).Returns(_variationData);
_populationRunResult = new PopulationRunResults {
Results = new SimulationResults()
};
A.CallTo(() => _populationRunner.RunPopulationAsync(_modelCoreSimulation, _runOptions, _dataTable, null, null)).ReturnsAsync(_populationRunResult);
_sensitivityAnalysisResults = new SensitivityAnalysisRunResult();
A.CallTo(() => _runResultCalculator.CreateFor(_sensitivityAnalysis, _variationData, _populationRunResult.Results, false)).Returns(_sensitivityAnalysisResults);
}
public async Task StartAsync(SensitivityAnalysis sensitivityAnalysis, SensitivityAnalysisRunOptions runOptions)
{
_sensitivityAnalysis = sensitivityAnalysis;
_eventPublisher.PublishEvent(new SensitivityAnalysisStartedEvent(sensitivityAnalysis));
try
{
var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(sensitivityAnalysis.Simulation, shouldCloneModel: true);
_simulationPersistableUpdater.UpdateSimulationPersistable(modelCoreSimulation);
var variationData = _sensitivityAnalysisVariationDataCreator.CreateForRun(sensitivityAnalysis);
var runResults = await _populationRunner.RunPopulationAsync(modelCoreSimulation, runOptions, variationData.ToDataTable());
sensitivityAnalysis.Results = await calculateSensitivityBasedOn(sensitivityAnalysis, variationData, runResults, runOptions);
_eventPublisher.PublishEvent(new SensitivityAnalysisResultsUpdatedEvent(sensitivityAnalysis));
}
finally
{
_eventPublisher.PublishEvent(new SensitivityAnalysisTerminatedEvent(sensitivityAnalysis));
_sensitivityAnalysis = null;
}
}
public async Task Run(SensitivityAnalysis sensitivityAnalysis, SensitivityAnalysisRunOptions runOptions = null)
{
if (!_entityValidationTask.Validate(sensitivityAnalysis))
{
return;
}
try
{
if (IsRunning)
{
throw new OSPSuiteException(Error.CannotStartTwoConcurrentSensitivityAnalyses);
}
var options = runOptions ?? new SensitivityAnalysisRunOptions {
NumberOfCoresToUse = _coreUserSettings.MaximumNumberOfCoresToUse
};
using (_sensitivityAnalysisEngine = _sensitivityAnalysisEngineFactory.Create())
{
var begin = SystemTime.UtcNow();
await _sensitivityAnalysisEngine.StartAsync(sensitivityAnalysis, options);
var end = SystemTime.UtcNow();
var timeSpent = end - begin;
_dialogCreator.MessageBoxInfo(Captions.SensitivityAnalysis.SensitivityAnalysisFinished(timeSpent.ToDisplay()));
}
}
catch (OperationCanceledException)
{
_dialogCreator.MessageBoxInfo(Captions.SensitivityAnalysis.SensitivityAnalysisCanceled);
}
finally
{
_executionContext.ProjectChanged();
_sensitivityAnalysisEngine = null;
}
}
private Task <SensitivityAnalysisRunResult> calculateSensitivityBasedOn(SensitivityAnalysis sensitivityAnalysis, VariationData variationData, PopulationRunResults runResults, SensitivityAnalysisRunOptions sensitivityAnalysisRunOptions)
{
return(Task.Run(() => _runResultCalculator.CreateFor(sensitivityAnalysis, variationData, runResults.Results, sensitivityAnalysisRunOptions.ReturnOutputValues)));
}
