protected override void Context()
{
_sensitivityAnalysisTask = A.Fake <ISensitivityAnalysisTask>();
_simulationAnalyzer = A.Fake <ISimulationAnalyzer>();
_parameterSelector = A.Fake <IParameterAnalysableParameterSelector>();
_containerTask = A.Fake <IContainerTask>();
_simulation = A.Fake <ISimulation>();
_sensitivityAnalysis = new SensitivityAnalysis(_simulation);
_coreSensitivityAnalysis = new Core.Domain.SensitivityAnalyses.SensitivityAnalysis();
sut = new SensitivityAnalysisToCoreSensitivityAnalysisMapper(_sensitivityAnalysisTask, _simulationAnalyzer, _parameterSelector, _containerTask);
_constantParameterCache = new PathCacheForSpecs <IParameter>
{
{ _parameterPath1, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P1") },
{ _parameterPath2, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P2") },
{ _parameterPath3, DomainHelperForSpecs.ConstantParameterWithValue(10).WithName("P3") }
};
A.CallTo(() => _sensitivityAnalysisTask.CreateSensitivityAnalysisFor(_simulation)).Returns(_coreSensitivityAnalysis);
A.CallTo(_containerTask).WithReturnType <PathCache <IParameter> >().Returns(_constantParameterCache);
_allSensitivityParametersCreated = new List <ParameterSelection>();
A.CallTo(() => _sensitivityAnalysisTask.AddParametersTo(_coreSensitivityAnalysis, A <IReadOnlyList <ParameterSelection> > ._))
.Invokes(x => _allSensitivityParametersCreated.AddRange(x.GetArgument <IReadOnlyList <ParameterSelection> >(1)));
}
protected override void Context()
{
base.Context();
_sensitivityAnalysis = new SensitivityAnalysis();
_sensitivityAnalysis.Simulation = _oldSimulation;
A.CallTo(() => _project.AllSensitivityAnalyses).Returns(new[] { _sensitivityAnalysis });
}
protected override void Context()
{
_sensitivityAnalysisParametersView = A.Fake <ISensitivityAnalysisParametersView>();
_sensitivityParameterFactory = A.Fake <ISensitivityParameterFactory>();
_sensitivityParameterToSensitivityParameterDTOMapper = A.Fake <ISensitivityParameterToSensitivityParameterDTOMapper>();
_sensitivityAnalysisSetNMaxPresenter = A.Fake <ISensitivityAnalysisSetValuePresenter>();
_sensitivityAnalysisSetRangePresenter = A.Fake <ISensitivityAnalysisSetValuePresenter>();
_sensitivityAnalysisTask = A.Fake <ISensitivityAnalysisTask>();
sut = new SensitivityAnalysisParametersPresenter(_sensitivityAnalysisParametersView, _sensitivityParameterFactory,
_sensitivityParameterToSensitivityParameterDTOMapper, _sensitivityAnalysisSetNMaxPresenter,
_sensitivityAnalysisSetRangePresenter, _sensitivityAnalysisTask);
_sensitivityAnalysis = new SensitivityAnalysis();
_parameterDTO = A.Fake <IParameterDTO>();
A.CallTo(() => _parameterDTO.Value).Returns(4.0);
_selectedSensitivityParameter = A.Fake <SensitivityParameter>();
_unSelectedSensitivityParameter = A.Fake <SensitivityParameter>();
_sensitivityAnalysis.AddSensitivityParameter(_selectedSensitivityParameter);
_sensitivityAnalysis.AddSensitivityParameter(_unSelectedSensitivityParameter);
A.CallTo(() => _selectedSensitivityParameter.NumberOfStepsParameter).Returns(new Parameter());
A.CallTo(() => _selectedSensitivityParameter.VariationRangeParameter).Returns(new Parameter());
A.CallTo(() => _unSelectedSensitivityParameter.NumberOfStepsParameter).Returns(new Parameter());
A.CallTo(() => _unSelectedSensitivityParameter.VariationRangeParameter).Returns(new Parameter());
_sensitivityParameterDTO = new SensitivityParameterDTO(_selectedSensitivityParameter);
A.CallTo(() => _sensitivityAnalysisParametersView.SelectedParameters()).Returns(new[] { _sensitivityParameterDTO });
A.CallTo(() => _sensitivityParameterToSensitivityParameterDTOMapper.MapFrom(_selectedSensitivityParameter)).Returns(_sensitivityParameterDTO);
A.CallTo(() => _sensitivityParameterToSensitivityParameterDTOMapper.MapFrom(_unSelectedSensitivityParameter)).Returns(new SensitivityParameterDTO(_unSelectedSensitivityParameter));
}
public async Task Run(SensitivityAnalysis sensitivityAnalysis)
{
if (!_entityValidationTask.Validate(sensitivityAnalysis))
{
return;
}
try
{
if (IsRunning)
{
throw new OSPSuiteException(Error.CannotStartTwoConcurrentSensitivityAnalyses);
}
using (_sensitivityAnalysisEngine = _sensitivityAnalysisEngineFactory.Create())
{
var begin = SystemTime.UtcNow();
await _sensitivityAnalysisEngine.StartAsync(sensitivityAnalysis);
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;
}
}
protected override void ActionForMissingSensitivityParameterPaths(SensitivityAnalysis sensitivityAnalysis, ISimulation newSimulation, SensitivityParameter sensitivityParameter)
{
_validationResult.AddMessage(
NotificationType.Warning,
sensitivityAnalysis,
Error.SensitivityAnalysis.SimulationDoesNotHaveParameterPath(newSimulation.Name, sensitivityParameter.ParameterSelection.Path));
}
public ValidationResult ValidateSwap(SensitivityAnalysis sensitivityAnalysis, ISimulation oldSimulation, ISimulation newSimulation)
{
_validationResult = new ValidationResult();
FindProblems(sensitivityAnalysis, oldSimulation, newSimulation);
return(_validationResult);
}
public static IMenuBarItem Edit(SensitivityAnalysis sensitivityAnalysis)
{
return(CreateMenuButton
.WithCaption(MenuNames.Edit)
.WithIcon(ApplicationIcons.Edit)
.WithCommandFor <EditSensitivityAnalysisUICommand, SensitivityAnalysis>(sensitivityAnalysis));
}
protected override void Context()
{
base.Context();
_sensitivityAnalysis = new SensitivityAnalysis();
_oldSimulation = A.Fake <ISimulation>();
_newSimulation = A.Fake <ISimulation>();
}
private void addSensitivityAnalysisToProject(SensitivityAnalysis sensitivityAnalysis, IOSPSuiteExecutionContext executionContext)
{
var project = executionContext.Project;
project.AddSensitivityAnalysis(sensitivityAnalysis);
executionContext.Register(sensitivityAnalysis);
executionContext.PublishEvent(new SensitivityAnalysisCreatedEvent(sensitivityAnalysis));
}
protected override void Context()
{
base.Context();
_sensitivityAnalysis = new SensitivityAnalysis {
Simulation = _oldSimulation
};
_project.AddSensitivityAnalysis(_sensitivityAnalysis);
}
private void updateSensitivityAnalysisItems(SensitivityAnalysis sensitivityAnalysis)
{
var hasResult = !_sensitivityRunning && sensitivityAnalysis.HasResults;
_menuBarItemRepository[MenuBarItemIds.RunSensitivityAnalysis].Enabled = !_sensitivityRunning;
_menuBarItemRepository[MenuBarItemIds.StopSensitivityAnalysis].Enabled = _sensitivityRunning;
_menuBarItemRepository[MenuBarItemIds.SensitivityAnalysisPKParameterAnalysis].Enabled = hasResult;
}
protected override void Context()
{
_presentationUserSettings = A.Fake <IPresentationUserSettings>();
_view = A.Fake <ISensitivityAnalysisFeedbackView>();
_sensitivityAnalysis = new SensitivityAnalysis();
sut = new SensitivityAnalysisFeedbackPresenter(_view, _presentationUserSettings);
}
private void delete(SensitivityAnalysis sensitivityAnalysis)
{
_applicationController.Close(sensitivityAnalysis);
_executionContext.Project.RemoveSensitivityAnalysis(sensitivityAnalysis);
_executionContext.Unregister(sensitivityAnalysis);
_executionContext.PublishEvent(new SensitivityAnalysisDeletedEvent(sensitivityAnalysis));
}
public SensitivityAnalysis Clone(SensitivityAnalysis sensitivityAnalysis)
{
_executionContext.Load(sensitivityAnalysis);
using (var clonePresenter = _applicationController.Start <ICloneObjectBasePresenter <SensitivityAnalysis> >())
{
return(clonePresenter.CreateCloneFor(sensitivityAnalysis));
}
}
public void EditSensitivityAnalysis(SensitivityAnalysis sensitivityAnalysis)
{
_sensitivityAnalysis = sensitivityAnalysis;
_sensitivityParameterForUpdates = _sensitivityParameterFactory.EmptySensitivityParameter();
_sensitivityAnalysisSetNMaxPresenter.Edit(_sensitivityParameterForUpdates.NumberOfStepsParameter);
_sensitivityAnalysisSetRangePresenter.Edit(_sensitivityParameterForUpdates.VariationRangeParameter);
updateView();
}
public DataTable MapFrom(SensitivityAnalysis sensitivityAnalysis, SensitivityAnalysisRunResult sensitivityAnalysisRunResult)
{
var dataTable = new DataTable(Captions.SensitivityAnalysis.Results);
dataTable.AddColumns <string>(Captions.SensitivityAnalysis.Output, Captions.SensitivityAnalysis.PKParameterName, Captions.SensitivityAnalysis.ParameterName, Captions.SensitivityAnalysis.ParameterDisplayPath, Captions.SensitivityAnalysis.PKParameterDescription, Captions.SensitivityAnalysis.ParameterPath);
dataTable.AddColumn <double>(Captions.SensitivityAnalysis.Value);
sensitivityAnalysisRunResult.AllPKParameterSensitivities.Each(x => addParameterSensitivity(x, dataTable, sensitivityAnalysis));
return(dataTable);
}
protected override void Context()
{
base.Context();
_sensitivityAnalysis = new SensitivityAnalysis().WithId("Id1");
_cloneSensitivityAnalysis = new SensitivityAnalysis().WithId("Id2");
var clonePresenter = A.Fake <ICloneObjectBasePresenter <SensitivityAnalysis> >();
A.CallTo(() => clonePresenter.CreateCloneFor(_sensitivityAnalysis)).Returns(_cloneSensitivityAnalysis);
A.CallTo(() => _applicationController.Start <ICloneObjectBasePresenter <SensitivityAnalysis> >()).Returns(clonePresenter);
}
private void removeSimulationFromAnalysis(ISimulation simulation, SensitivityAnalysis sensitivityAnalysis)
{
if (!Equals(sensitivityAnalysis.Simulation, simulation))
{
return;
}
removeSensitivityParameters(sensitivityAnalysis);
sensitivityAnalysis.Simulation = null;
}
public SensitivityParameter CreateFor(ParameterSelection parameterSelection, SensitivityAnalysis sensitivityAnalysis)
{
if (sensitivityAnalysis.AnalyzesParameter(parameterSelection))
{
return(null);
}
var nameToUse = uniqueNameFor(sensitivityAnalysis, parameterSelection.Parameter);
return(createSensitivityParameter(parameterSelection, nameToUse));
}
public void LoadContentFor(SensitivityAnalysis sensitivityAnalysis)
{
var content = _sensitivityAnalysisMetaDataContentQuery.ResultFor(sensitivityAnalysis.Id);
if (content?.Data == null)
{
return;
}
_compressedSerializationManager.Deserialize(sensitivityAnalysis, content.Data);
}
protected override void Context()
{
base.Context();
_validationResult = new ValidationResult();
_sensitivityAnalysis = new SensitivityAnalysis();
_oldSimulation = A.Fake <ISimulation>();
_newSimulation = A.Fake <ISimulation>();
_validationResult.AddMessage(NotificationType.Warning, _sensitivityAnalysis, "this is text");
A.CallTo(() => _sensitivityAnalysisSwapValidator.ValidateSwap(_sensitivityAnalysis, _oldSimulation, _newSimulation)).Returns(_validationResult);
}
public static IEnumerable <IMenuBarItem> ContextMenuItemsFor(SensitivityAnalysis sensitivityAnalysis)
{
yield return(Edit(sensitivityAnalysis));
yield return(Rename(sensitivityAnalysis));
yield return(Clone(sensitivityAnalysis).AsGroupStarter());
yield return(AddToJournal(sensitivityAnalysis));
yield return(Delete(sensitivityAnalysis).AsGroupStarter());
}
public void SwapSimulations(SensitivityAnalysis sensitivityAnalysis, ISimulation oldSimulation, ISimulation newSimulation)
{
loadSimulation(newSimulation);
if (Equals(newSimulation, oldSimulation))
{
return;
}
_sensitivityAnalysisSimulationSwapCorrector.CorrectSensitivityAnalysis(sensitivityAnalysis, oldSimulation, newSimulation);
sensitivityAnalysis.SwapSimulations(oldSimulation, newSimulation);
_executionContext.PublishEvent(new SimulationReplacedInParameterAnalyzableEvent(sensitivityAnalysis, oldSimulation, newSimulation));
}
protected override void Context()
{
_simulation = A.Fake <ISimulation>();
A.CallTo(() => _simulation.OutputSelections.HasSelection).Returns(true);
_sensitivityAnalysis = new SensitivityAnalysis {
Simulation = _simulation
};
sut = new SensitivityAnalysisValidator();
_sensitivityParameter = DomainHelperForSpecs.SensitivityParameter();
_sensitivityParameter.ParameterSelection = A.Fake <ParameterSelection>();
}
public void UpdateSensitivityParameterName(SensitivityAnalysis sensitivityAnalysis, SensitivityParameter sensitivityParameter, string newName)
{
var oldName = sensitivityParameter.Name;
sensitivityParameter.Name = newName;
if (!sensitivityAnalysis.HasResults)
{
return;
}
sensitivityAnalysis.Results.UpdateSensitivityParameterName(oldName, newName);
_executionContext.PublishEvent(new SensitivityAnalysisResultsUpdatedEvent(sensitivityAnalysis));
}
public SensitivityAnalysisRunResult CreateFor(SensitivityAnalysis sensitivityAnalysis, VariationData variationData, SimulationResults simulationResults, bool addOutputParameterSensitivitiesToResult)
{
var sensitivityRunResult = new SensitivityAnalysisRunResult();
addPKAnalysisSensitivities(variationData, simulationResults, sensitivityRunResult, sensitivityAnalysis);
if (addOutputParameterSensitivitiesToResult)
{
addOutputSensitivities(variationData, simulationResults, sensitivityRunResult, sensitivityAnalysis);
}
return(sensitivityRunResult);
}
protected override void Context()
{
_pkAnalysisTask = A.Fake <ISensitivityAnalysisPKAnalysesTask>();
sut = new SensitivityAnalysisRunResultCalculator(_pkAnalysisTask);
_pkAnalyses = new PopulationSimulationPKAnalyses();
_sensitivityAnalysis = new SensitivityAnalysis();
_variationData = new VariationData();
_simulationResults = new SimulationResults();
A.CallTo(_pkAnalysisTask).WithReturnType <PopulationSimulationPKAnalyses>().Returns(_pkAnalyses);
}
protected override void Context()
{
base.Context();
_fractionDimension = A.Fake <IDimension>();
_parameterSelection = A.Fake <ParameterSelection>();
_parameterSelection.Parameter.Name = "XX";
_sensitivityAnalysis = new SensitivityAnalysis();
A.CallTo(_containerTask).WithReturnType <string>().Returns("YY");
A.CallTo(() => _objectBaseFactory.Create <ConstantFormula>()).ReturnsLazily(x => new ConstantFormula());
A.CallTo(() => _objectBaseFactory.Create <SensitivityParameter>()).Returns(new SensitivityParameter());
A.CallTo(() => _objectBaseFactory.Create <IParameter>()).ReturnsLazily(x => new Parameter());
A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.FRACTION)).Returns(_fractionDimension);
}
public void LoadContentFor(SensitivityAnalysis sensitivityAnalysis)
{
var content = _sensitivityAnalysisMetaDataContentQuery.ResultFor(sensitivityAnalysis.Id);
if (content?.Data == null)
{
return;
}
using (var context = _serializationContextFactory.Create(externalReferences: _projectRetriever.CurrentProject.All <ISimulation>()))
{
_compressedSerializationManager.Deserialize(sensitivityAnalysis, content.Data, context);
}
}
protected override void Context()
{
_eventPublisher = A.Fake <IEventPublisher>();
_sensitivityAnalysisVariationDataCreator = A.Fake <ISensitivityAnalysisVariationDataCreator>();
_populationRunner = A.Fake <IPopulationRunner>();
_modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>();
_runResultCalculator = A.Fake <ISensitivityAnalysisRunResultCalculator>();
_simulationPersistableUpdater = A.Fake <ISimulationPersistableUpdater>();
sut = new SensitivityAnalysisEngine(_eventPublisher, _sensitivityAnalysisVariationDataCreator, _populationRunner, _modelCoreSimulationMapper, _runResultCalculator, _simulationPersistableUpdater);
_sensitivityAnalysis = A.Fake <SensitivityAnalysis>();
_modelCoreSimulation = A.Fake <IModelCoreSimulation>();
A.CallTo(() => _modelCoreSimulationMapper.MapFrom(_sensitivityAnalysis.Simulation, true)).Returns(_modelCoreSimulation);
}
