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); }