protected override void Context() { _parameterTask = A.Fake <ISetParameterTask>(); _dialogCreator = A.Fake <IDialogCreator>(); _parameterIdentification = new ParameterIdentification(); _runResult = new ParameterIdentificationRunResult(); _runResult.BestResult.AddValue(new OptimizedParameterValue("P1", 10, 20)); _runResult.BestResult.AddValue(new OptimizedParameterValue("P2", 4, 5)); _identificationParameter1 = new IdentificationParameter { Name = "P1" }; _identificationParameter2 = new IdentificationParameter { Name = "P2", UseAsFactor = true }; _identificationParameter3 = new IdentificationParameter { Name = "P3", IsFixed = true, }; _identificationParameter3.Add(DomainHelperForSpecs.ConstantParameterWithValue(25).WithName(Constants.Parameters.START_VALUE)); _linkedParameter1 = A.Fake <ParameterSelection>(); A.CallTo(() => _linkedParameter1.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(2)); _linkedParameter2 = A.Fake <ParameterSelection>(); A.CallTo(() => _linkedParameter2.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(3)); A.CallTo(() => _linkedParameter2.Dimension).Returns(Constants.Dimension.NO_DIMENSION); _linkedParameter3 = A.Fake <ParameterSelection>(); A.CallTo(() => _linkedParameter3.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(4)); A.CallTo(() => _linkedParameter3.Dimension).Returns(Constants.Dimension.NO_DIMENSION); _linkedParameter4 = A.Fake <ParameterSelection>(); A.CallTo(() => _linkedParameter4.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(5)); A.CallTo(() => _linkedParameter4.Dimension).Returns(Constants.Dimension.NO_DIMENSION); _identificationParameter1.AddLinkedParameter(_linkedParameter1); _identificationParameter2.AddLinkedParameter(_linkedParameter2); _identificationParameter2.AddLinkedParameter(_linkedParameter3); _identificationParameter3.AddLinkedParameter(_linkedParameter4); _parameterIdentification.AddIdentificationParameter(_identificationParameter1); _parameterIdentification.AddIdentificationParameter(_identificationParameter2); _parameterIdentification.AddIdentificationParameter(_identificationParameter3); _context = A.Fake <IOSPSuiteExecutionContext>(); sut = new TestTransferOptimizedParametersToSimulationsTask(_parameterTask, _dialogCreator, _context); _allValueOriginCommands = new List <ICommand>(); A.CallTo(() => _parameterTask.SetParameterValue(A <IParameter> ._, A <double> ._, A <ISimulation> ._)).ReturnsLazily(x => A.Fake <IOSPSuiteCommmand <IOSPSuiteExecutionContext> >()); A.CallTo(() => _parameterTask.UpdateParameterValueOrigin(A <IParameter> ._, A <ValueOrigin> ._, A <ISimulation> ._)).ReturnsLazily(x => { var command = A.Fake <IOSPSuiteCommmand <IOSPSuiteExecutionContext> >(); _allValueOriginCommands.Add(command); return(command); }); }
protected override void Context() { base.Context(); _gaussData = new DataTable(); _distributionData = A.Fake <ContinuousDistributionData>(); A.CallTo(_normalDistributionDataCreator).WithReturnType <DataTable>().Returns(_gaussData); A.CallTo(() => _histogramView.BindTo(_gaussData, _distributionData, A <DistributionSettings> ._)) .Invokes(x => _distributionSettings = x.GetArgument <DistributionSettings>(2)); _badResult = A.Fake <ParameterIdentificationRunResult>(); _goodResult = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _badResult.TotalError).Returns(5); A.CallTo(() => _goodResult.TotalError).Returns(1); _parameterIdentification.AddResult(_badResult); _parameterIdentification.AddResult(_goodResult); A.CallTo(() => _residualDataCreator.CreateFor(_goodResult.BestResult)).Returns(_distributionData); _residuals = new [] { 10d, 20d, 30d }; A.CallTo(() => _goodResult.BestResult.AllResidualValues).Returns(_residuals); }
protected override void Context() { _runResultDTOMapper = A.Fake <IParameterIdentificationRunResultToRunResultDTOMapper>(); _view = A.Fake <IMultipleParameterIdentificationResultsView>(); _transferOptimizedParametersToSimulationTask = A.Fake <ITransferOptimizedParametersToSimulationsTask>(); _commandCollector = A.Fake <ICommandCollector>(); sut = new MultipleParameterIdentificationResultsPresenter(_view, _runResultDTOMapper, _transferOptimizedParametersToSimulationTask); sut.InitializeWith(_commandCollector); _parameterIdentification = new ParameterIdentification(); _runResult1 = A.Fake <ParameterIdentificationRunResult>(); _runResult2 = A.Fake <ParameterIdentificationRunResult>(); _parameterIdentification.AddResult(_runResult1); _parameterIdentification.AddResult(_runResult2); _dto1 = new ParameterIdentificationRunResultDTO(_runResult1); _dto2 = new ParameterIdentificationRunResultDTO(_runResult2); A.CallTo(() => _runResultDTOMapper.MapFrom(_parameterIdentification, _runResult1)).Returns(_dto1); A.CallTo(() => _runResultDTOMapper.MapFrom(_parameterIdentification, _runResult2)).Returns(_dto2); A.CallTo(() => _view.BindTo(A <IEnumerable <ParameterIdentificationRunResultDTO> > ._)) .Invokes(x => _allParameterIdentificationRunResultDTO = x.GetArgument <IEnumerable <ParameterIdentificationRunResultDTO> >(0).ToList()); }
protected override void AddRunResultToChart(ParameterIdentificationRunResult selectedRunResults) { if (ChartIsBeingCreated || ChartIsBeingUpdated) { var confidenceIntervalRepositories = _confidenceIntervalFunc(_timeProfileConfidenceIntervalCalculator)(_parameterIdentification, selectedRunResults); Chart.ClearDataRepositories(); if (confidenceIntervalRepositories.Any()) { AddUsedObservedDataToChart(); Chart.AddRepositories(confidenceIntervalRepositories); resetChartTitleIfRequired(); } else { Chart.Title = Captions.ParameterIdentification.ConfidenceIntervalNotAvailable; } if (ChartIsBeingCreated) { addDefaultCurves(); } } AddResultRepositoriesToEditor(Chart.DataRepositories); UpdateChartFromTemplate(); }
protected override void AddRunResultToChart(ParameterIdentificationRunResult runResult) { addPredictedVsObservedToChart(runResult.BestResult.SimulationResults, (column, curve) => { curve.Description = CurveDescription(curve.Name, runResult); curve.Name = column.PathAsString; }); }
protected override void Context() { base.Context(); _runResult = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _runResult.TotalError).Returns(0.5); A.CallTo(() => _runResult.NumberOfEvaluations).Returns(10); A.CallTo(() => _runResult.Duration).Returns(TimeSpan.FromMinutes(2)); A.CallTo(() => _runResult.Status).Returns(RunStatus.RanToCompletion); }
protected override void Context() { base.Context(); _parameterIdentification = new ParameterIdentification(); _simulationResult = DomainHelperForSpecs.SimulationDataRepositoryFor("SIM"); var runResult = new ParameterIdentificationRunResult(); runResult.BestResult.AddResult(_simulationResult); _parameterIdentification.AddResult(runResult); }
public void EditParameterIdentification(ParameterIdentification parameterIdentification) { _parameterIdentification = parameterIdentification; //We expect one result when landing here. _result = parameterIdentification.Results[0]; _resultDTO = _runResultDTOMapper.MapFrom(parameterIdentification, _result); _view.BindTo(_resultDTO); _runPropertiesPresenter.Edit(_result); }
protected string CurveDescription(string name, ParameterIdentificationRunResult runResult) { int?runIndex = null; if (_isMultipleRun) { runIndex = runResult.Index; } return(Captions.ParameterIdentification.CreateCurveDescription(name, runIndex, runResult.Description)); }
private void mapProperties(ParameterIdentificationRunResult runResult) { _allProperties.Add(new RunPropertyDTO <double>(Captions.ParameterIdentification.TotalError, runResult.TotalError, new DoubleFormatter())); _allProperties.Add(new RunPropertyDTO <int>(Captions.ParameterIdentification.NumberOfEvaluations, runResult.NumberOfEvaluations, new IntFormatter())); _allProperties.Add(new RunPropertyDTO <TimeSpan>(Captions.ParameterIdentification.Duration, runResult.Duration, new TimeSpanFormatter())); _allProperties.Add(new RunPropertyDTO <RunStatus>(Captions.ParameterIdentification.Status, runResult.Status, icon: runResult.Status.Icon)); if (!string.IsNullOrEmpty(runResult.Message)) { _allProperties.Add(new RunPropertyDTO <string>(Captions.ParameterIdentification.RunMessage, runResult.Message, icon: runResult.Status.Icon)); } }
protected override void Context() { _runResultDTOMapper = A.Fake <IParameterIdentificationRunResultToRunResultDTOMapper>(); _view = A.Fake <ISingleParameterIdentificationResultsView>(); _runPropertiesPresenter = A.Fake <IParameterIdentificationRunPropertiesPresenter>(); _transferParametersToSimulationTask = A.Fake <ITransferOptimizedParametersToSimulationsTask>(); sut = new SingleParameterIdentificationResultsPresenter(_view, _runPropertiesPresenter, _runResultDTOMapper, _transferParametersToSimulationTask); _parameterIdentification = new ParameterIdentification(); _runResult = A.Fake <ParameterIdentificationRunResult>(); _parameterIdentification.AddResult(_runResult); }
protected override void Context() { _confidenceIntervalCalculator = A.Fake <IConfidenceIntervalCalculator>(); _view = A.Fake <IParameterIdentificationConfidenceIntervalView>(); sut = new ParameterIdentificationConfidenceIntervalPresenter(_view, _confidenceIntervalCalculator); _parameterIdentification = A.Fake <ParameterIdentification>(); _runResult = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _view.BindTo(A <IEnumerable <ParameterConfidenceIntervalDTO> > ._)) .Invokes(x => _allParameterConfidenceIntervalDTOs = x.GetArgument <IEnumerable <ParameterConfidenceIntervalDTO> >(0).ToList()); }
private IReadOnlyList <DataRepository> calculateConfidenceIntervalFor(ParameterIdentification parameterIdentification, ParameterIdentificationRunResult runResult, string confidenceIntervalName, Func <Scalings, double, double, double, double> intervalCalculation, bool requiresActiveOutput) { var dataRepositories = new List <DataRepository>(); if (runResult.JacobianMatrix == null) { return(dataRepositories); } var residualsResult = runResult.BestResult.ResidualsResult; var allResiduals = residualsResult.AllResidualsWithWeightsStrictBiggerZero; var nr = allResiduals.Count; var np = parameterIdentification.AllVariableIdentificationParameters.Count(); var df = nr - np; if (df <= 0) { return(dataRepositories); } var Q = residualsResult.SumResidual2; try { _sigma = Math.Sqrt(Q / df); _runResult = runResult; var covariance = _matrixCalculator.CovarianceMatrixFrom(runResult.JacobianMatrix, residualsResult); _covP = Matrix <double> .Build.DenseOfRowArrays(covariance.Rows); var qt = new StudentT(0.0, 1, df); _dt = qt.InverseCumulativeDistribution(1 - Constants.CONFIDENCE_INTERVAL_ALPHA / 2); parameterIdentification.AllOutputMappings.GroupBy(x => x.FullOutputPath).Each(x => { var outputMapping = x.ElementAt(0); var dataRepository = _dataRepositoryCreator.CreateFor(confidenceIntervalName, confidanceIntervalFor(outputMapping, intervalCalculation, requiresActiveOutput), outputMapping, runResult.BestResult); if (!dataRepository.IsNull()) { dataRepositories.Add(dataRepository); } }); return(dataRepositories); } finally { _covP = null; _sigma = double.NaN; _dt = double.NaN; _runResult = null; } }
protected override void Context() { _presentationSettingsTask = A.Fake <IPresentationSettingsTask>(); _view = A.Fake <IParameterIdentificationMultipleRunsAnalysisView>(); _chartEditorAndDisplayPresenter = A.Fake <IChartEditorAndDisplayPresenter>(); _curveNamer = A.Fake <ICurveNamer>(); _pathElementsMapper = A.Fake <IDataColumnToPathElementsMapper>(); _chartTemplatingTask = A.Fake <IChartTemplatingTask>(); _dimensionFactory = A.Fake <IDimensionFactory>(); _displayUnitRetriever = A.Fake <IDisplayUnitRetriever>(); _chartEditorLayoutTask = A.Fake <IChartEditorLayoutTask>(); _projectRetreiver = A.Fake <IProjectRetriever>(); _chartPresenterContext = A.Fake <ChartPresenterContext>(); A.CallTo(() => _chartPresenterContext.EditorAndDisplayPresenter).Returns(_chartEditorAndDisplayPresenter); A.CallTo(() => _chartPresenterContext.CurveNamer).Returns(_curveNamer); A.CallTo(() => _chartPresenterContext.DataColumnToPathElementsMapper).Returns(_pathElementsMapper); A.CallTo(() => _chartPresenterContext.TemplatingTask).Returns(_chartTemplatingTask); A.CallTo(() => _chartPresenterContext.PresenterSettingsTask).Returns(_presentationSettingsTask); A.CallTo(() => _chartPresenterContext.DimensionFactory).Returns(_dimensionFactory); A.CallTo(() => _chartPresenterContext.EditorLayoutTask).Returns(_chartEditorLayoutTask); A.CallTo(() => _chartPresenterContext.ProjectRetriever).Returns(_projectRetreiver); sut = new ParameterIdentificationTimeProfileChartPresenter(_view, _chartPresenterContext, _displayUnitRetriever); _timeProfileAnalysis = new ParameterIdentificationTimeProfileChart(); _outputMapping1 = A.Fake <OutputMapping>(); _outputMapping2 = A.Fake <OutputMapping>(); _observedData1 = DomainHelperForSpecs.ObservedData(); _observedData2 = DomainHelperForSpecs.ObservedData(); A.CallTo(() => _outputMapping1.WeightedObservedData).Returns(new WeightedObservedData(_observedData1)); A.CallTo(() => _outputMapping2.WeightedObservedData).Returns(new WeightedObservedData(_observedData2)); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.AddOutputMapping(_outputMapping1); _parameterIdentification.AddOutputMapping(_outputMapping2); _parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>(); _parameterIdentification.AddResult(_parameterIdentificationRunResult); _optimizationRunResult = new OptimizationRunResult(); _parameterIdentificationRunResult.BestResult = _optimizationRunResult; _parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>(); _parameterIdentification.AddResult(_parameterIdentificationRunResult); _optimizationRunResult2 = new OptimizationRunResult(); _parameterIdentificationRunResult.BestResult = _optimizationRunResult2; }
protected override async Task Context() { await base.Context(); _result1 = A.Fake <ParameterIdentificationRunResult>(); _result2 = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _result1.TotalError).Returns(10); A.CallTo(() => _result2.TotalError).Returns(2); A.CallTo(() => _parameterIdentificationEngine.StartAsync(_parameterIdentification)).Invokes(x => { _parameterIdentification.AddResult(_result1); _parameterIdentification.AddResult(_result2); }); }
protected override void Context() { base.Context(); _optimizedParameterValue = new OptimizedParameterValue("PARAM", 10, 20, 0, 0, Scalings.Linear); _parameterIdentification = new ParameterIdentification(); _identificationParameter = DomainHelperForSpecs.IdentificationParameter("PARAM", 0.1, 100, 20); _identificationParameter.Scaling = Scalings.Log; _parameterIdentification.AddIdentificationParameter(_identificationParameter); var runResult = new ParameterIdentificationRunResult(); runResult.BestResult.AddValue(_optimizedParameterValue); _parameterIdentification.AddResult(runResult); }
private void addCurvesFor(ParameterIdentificationRunResult runResult, bool curveVisible, DataRepository simulationResult) { AddCurvesFor(simulationResult, (column, curve) => { UpdateColorForCalculationColumn(curve, column); curve.Visible = curveVisible; curve.Description = CurveDescription(curve.Name, runResult); adjustAxes(column); if (!_isMultipleRun) { return; } curve.Name = $"{runResult.Index}-{curve.Name}"; }); }
protected override void Context() { _view = A.Fake <IParameterIdentificationSingleRunAnalysisView>(); _chartEditorAndDisplayPresenter = A.Fake <IChartEditorAndDisplayPresenter>(); _curveNamer = A.Fake <ICurveNamer>(); _dataColumnToPathElementsMapper = A.Fake <IDataColumnToPathElementsMapper>(); _chartTemplatingTask = A.Fake <IChartTemplatingTask>(); _presentationSettingsTask = A.Fake <IPresentationSettingsTask>(); _dimensionFactory = A.Fake <IDimensionFactory>(); _predictedVsObservedService = A.Fake <IPredictedVsObservedChartService>(); _chartEditorLayoutTask = A.Fake <IChartEditorLayoutTask>(); _projectRetreiver = A.Fake <IProjectRetriever>(); _chartPresenterContext = A.Fake <ChartPresenterContext>(); A.CallTo(() => _chartPresenterContext.EditorAndDisplayPresenter).Returns(_chartEditorAndDisplayPresenter); A.CallTo(() => _chartPresenterContext.CurveNamer).Returns(_curveNamer); A.CallTo(() => _chartPresenterContext.DataColumnToPathElementsMapper).Returns(_dataColumnToPathElementsMapper); A.CallTo(() => _chartPresenterContext.TemplatingTask).Returns(_chartTemplatingTask); A.CallTo(() => _chartPresenterContext.PresenterSettingsTask).Returns(_presentationSettingsTask); A.CallTo(() => _chartPresenterContext.DimensionFactory).Returns(_dimensionFactory); A.CallTo(() => _chartPresenterContext.EditorLayoutTask).Returns(_chartEditorLayoutTask); A.CallTo(() => _chartPresenterContext.ProjectRetriever).Returns(_projectRetreiver); _observationData = DomainHelperForSpecs.ObservedData(); _simulationData = DomainHelperForSpecs.IndividualSimulationDataRepositoryFor("Simulation"); _noDimensionColumnForSimulation = _simulationData.FirstDataColumn(); _predictedVsObservedChart = new ParameterIdentificationPredictedVsObservedChart().WithAxes(); _parameterIdentification = A.Fake <ParameterIdentification>(); sut = new ParameterIdentificationPredictedVsObservedChartPresenter(_view, _chartPresenterContext, _predictedVsObservedService); _parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _parameterIdentification.Results).Returns(new[] { _parameterIdentificationRunResult }); _residualResults = new ResidualsResult(); _optimizationRunResult = new OptimizationRunResult { ResidualsResult = _residualResults, SimulationResults = new List <DataRepository> { _simulationData } }; _parameterIdentificationRunResult.BestResult = _optimizationRunResult; sut.InitializeAnalysis(_predictedVsObservedChart); }
protected override void Context() { _rangeImageCreator = A.Fake <IOptimizedParameterRangeImageCreator>(); sut = new ParameterIdentificationRunResultToRunResultDTOMapper(_rangeImageCreator); _parameterIdentification = new ParameterIdentification(); _runResult = A.Fake <ParameterIdentificationRunResult>().WithDescription("Desc"); _runResult.Index = 5; _optimizationRunResult = new OptimizationRunResult(); _runResult.BestResult = _optimizationRunResult; A.CallTo(() => _runResult.NumberOfEvaluations).Returns(10); A.CallTo(() => _runResult.TotalError).Returns(5); _identificationParameter1 = new IdentificationParameter().WithName("P1"); _identificationParameter1.Add(parameterNamed(1, Constants.Parameters.MIN_VALUE)); _identificationParameter1.Add(parameterNamed(2, Constants.Parameters.START_VALUE)); _identificationParameter1.Add(parameterNamed(3, Constants.Parameters.MAX_VALUE)); _identificationParameter2 = new IdentificationParameter().WithName("P2"); _identificationParameter2.Add(parameterNamed(4, Constants.Parameters.MIN_VALUE)); _identificationParameter2.Add(parameterNamed(5, Constants.Parameters.START_VALUE)); _identificationParameter2.Add(parameterNamed(6, Constants.Parameters.MAX_VALUE)); _identificationParameter3 = new IdentificationParameter().WithName("P3"); _identificationParameter3.Add(parameterNamed(7, Constants.Parameters.MIN_VALUE)); _identificationParameter3.Add(parameterNamed(8, Constants.Parameters.START_VALUE)); _identificationParameter3.Add(parameterNamed(9, Constants.Parameters.MAX_VALUE)); _identificationParameter3.IsFixed = true; _parameterIdentification.AddIdentificationParameter(_identificationParameter1); _parameterIdentification.AddIdentificationParameter(_identificationParameter2); _parameterIdentification.AddIdentificationParameter(_identificationParameter3); _optimizedParameterValue1 = new OptimizedParameterValue("P1", 2.5, 2.1); _optimizationRunResult.AddValue(_optimizedParameterValue1); _optimizedParameterValue2 = new OptimizedParameterValue("P2", 5.5, 5.2); _optimizationRunResult.AddValue(_optimizedParameterValue2); //does not exist in PI anymore _optimizationRunResult.AddValue(new OptimizedParameterValue("P DOES NOT EXIST", 50, 60)); A.CallTo(_rangeImageCreator).WithReturnType <Image>().Returns(ApplicationIcons.OK); }
protected override void Context() { _presentationSettingsTask = A.Fake <IPresentationSettingsTask>(); _view = A.Fake <IParameterIdentificationSingleRunAnalysisView>(); _chartEditorAndDisplayPresenter = A.Fake <IChartEditorAndDisplayPresenter>(); _curveNamer = A.Fake <ICurveNamer>(); _pathElementsMapper = A.Fake <IDataColumnToPathElementsMapper>(); _chartTemplatingTask = A.Fake <IChartTemplatingTask>(); _dimensionFactory = A.Fake <IDimensionFactory>(); _chartEditorLayoutTask = A.Fake <IChartEditorLayoutTask>(); _projectRetreiver = A.Fake <IProjectRetriever>(); _chartPresenterContext = A.Fake <ChartPresenterContext>(); A.CallTo(() => _chartPresenterContext.EditorAndDisplayPresenter).Returns(_chartEditorAndDisplayPresenter); A.CallTo(() => _chartPresenterContext.CurveNamer).Returns(_curveNamer); A.CallTo(() => _chartPresenterContext.DataColumnToPathElementsMapper).Returns(_pathElementsMapper); A.CallTo(() => _chartPresenterContext.TemplatingTask).Returns(_chartTemplatingTask); A.CallTo(() => _chartPresenterContext.PresenterSettingsTask).Returns(_presentationSettingsTask); A.CallTo(() => _chartPresenterContext.DimensionFactory).Returns(_dimensionFactory); A.CallTo(() => _chartPresenterContext.EditorLayoutTask).Returns(_chartEditorLayoutTask); A.CallTo(() => _chartPresenterContext.ProjectRetriever).Returns(_projectRetreiver); sut = new ParameterIdentificationResidualVsTimeChartPresenter(_view, _chartPresenterContext); _residualVsTimeChart = new ParameterIdentificationResidualVsTimeChart().WithAxes(); _parameterIdentification = A.Fake <ParameterIdentification>(); _parameterIdentificationRunResult = A.Fake <ParameterIdentificationRunResult>(); A.CallTo(() => _parameterIdentification.Results).Returns(new[] { _parameterIdentificationRunResult }); _residualResults = new ResidualsResult(); _optimizationRunResult = new OptimizationRunResult { ResidualsResult = _residualResults }; _parameterIdentificationRunResult.BestResult = _optimizationRunResult; A.CallTo(() => _parameterIdentification.MinObservedDataTime).Returns(10); A.CallTo(() => _parameterIdentification.MaxObservedDataTime).Returns(50); }
protected override void Context() { base.Context(); _simulation = A.Fake <ISimulation>(); _project = A.Fake <IProject>(); _parameterIdentification = new ParameterIdentification(); A.CallTo(() => _executionContext.Project).Returns(_project); A.CallTo(() => _project.AllParameterIdentifications).Returns(new[] { _parameterIdentification }); _parameterIdentification.AddSimulation(_simulation); _initialObjectPath = new ObjectPath("oldName", "path"); var parameterIdentificationRunResult = new ParameterIdentificationRunResult { BestResult = new OptimizationRunResult() }; _simulationDataRepository = DomainHelperForSpecs.SimulationDataRepositoryFor("oldName"); _observationDataRepository = DomainHelperForSpecs.ObservedData(); _observationDataRepository.AllButBaseGrid().Each(x => x.QuantityInfo.Path = _initialObjectPath); _simulationDataRepository.AllButBaseGrid().Each(x => x.QuantityInfo.Path = _initialObjectPath); parameterIdentificationRunResult.BestResult.AddResult(_simulationDataRepository); _residualsResult = new ResidualsResult(); _residualsResult.AddOutputResiduals(_initialObjectPath.PathAsString, _observationDataRepository, new List <Residual> { new Residual(0, 1, 1) }); parameterIdentificationRunResult.BestResult.ResidualsResult = _residualsResult; _parameterIdentification.AddResult(parameterIdentificationRunResult); var outputMapping = new OutputMapping { WeightedObservedData = new WeightedObservedData(_observationDataRepository), OutputSelection = new ParameterSelection(_simulation, _initialObjectPath.PathAsString) }; _parameterIdentification.AddOutputMapping(outputMapping); }
public ParameterIdentificationRunResultDTO MapFrom(ParameterIdentification parameterIdentification, ParameterIdentificationRunResult runResult) { var runResultDTO = new ParameterIdentificationRunResultDTO(runResult); runResult.BestResult.Values.Each(x => { var optimizedParameterDTO = mapFrom(x, parameterIdentification); addOptimizedParameterDTOTo(runResultDTO, optimizedParameterDTO); }); parameterIdentification.AllFixedIdentificationParameters.Each(x => { var fixedParameterDTO = mapFrom(x, x.StartValue, x.StartValue); addOptimizedParameterDTOTo(runResultDTO, fixedParameterDTO); }); return(runResultDTO); }
public ICommand TransferParametersFrom(ParameterIdentification parameterIdentification, ParameterIdentificationRunResult runResult) { if (runResult.Status == RunStatus.Canceled) { var res = _dialogCreator.MessageBoxYesNo(Warning.ImportingParameterIdentificationValuesFromCancelledRun); if (res == ViewResult.No) { return(new OSPSuiteEmptyCommand <TExecutionContext>()); } } if (parameterIdentification.IsCategorialRunMode()) { _dialogCreator.MessageBoxInfo(Warning.ImportingParameterIdentificationValuesFromCategorialRun); } var macroCommand = new OSPSuiteMacroCommand <TExecutionContext> { BuildingBlockType = ObjectTypes.Simulation, CommandType = Command.CommandTypeEdit, ObjectType = ObjectTypes.Simulation, Description = Captions.ParameterIdentification.ParameterIdentificationTransferredToSimulations(parameterIdentification.Name) }; foreach (var optimizedParameter in runResult.BestResult.Values) { var identificationParameter = parameterIdentification.IdentificationParameterByName(optimizedParameter.Name); if (identificationParameter == null) { throw new OSPSuiteException(Error.IdentificationParameterCannotBeFound(optimizedParameter.Name)); } macroCommand.AddRange(setOptimalParameterValueIn(identificationParameter, optimizedParameter.Value)); } macroCommand.AddRange(parameterIdentification.AllFixedIdentificationParameters.SelectMany(x => setOptimalParameterValueIn(x, x.StartValue))); return(macroCommand); }
protected override void Context() { _matrixCalculator = A.Fake <IMatrixCalculator>(); _dataRepositoryCreator = A.Fake <IConfidenceIntervalDataRepositoryCreator>(); sut = new TimeProfileConfidenceIntervalCalculator(_matrixCalculator, _dataRepositoryCreator); _identificationParameter1 = new IdentificationParameter().WithName("IP1"); _identificationParameter2 = new IdentificationParameter().WithName("IP2"); var parameterNames = new[] { _identificationParameter1.Name, _identificationParameter2.Name }; _parameterIdentification = A.Fake <ParameterIdentification>(); _runResult = A.Fake <ParameterIdentificationRunResult>(); _runResult.JacobianMatrix = new JacobianMatrix(parameterNames); _allOutputMappings = new List <OutputMapping>(); _allVariableIdentificationParameters = new List <IdentificationParameter>(); _residualResults = new ResidualsResult(); _runResult.BestResult.ResidualsResult = _residualResults; A.CallTo(() => _parameterIdentification.AllOutputMappings).Returns(_allOutputMappings); A.CallTo(() => _parameterIdentification.AllVariableIdentificationParameters).Returns(_allVariableIdentificationParameters); _simulation1 = A.Fake <ISimulation>().WithName("S1"); _simulation2 = A.Fake <ISimulation>().WithName("S2"); _output1 = createOutput(_simulation1, "C1", Scalings.Log); _allOutputMappings.Add(_output1); _output2 = createOutput(_simulation2, "C2", Scalings.Linear); _allOutputMappings.Add(_output2); _output3 = createOutput(_simulation1, "C3", Scalings.Log); _allOutputMappings.Add(_output3); _output4 = createOutput(_simulation2, "C4", Scalings.Linear); _allOutputMappings.Add(_output4); _ps1_1 = createParameterSelection(_simulation1, "P1_1"); _identificationParameter1.AddLinkedParameter(_ps1_1); _ps2_1 = createParameterSelection(_simulation1, "P2_1"); A.CallTo(() => _ps2_1.Dimension).Returns(_ps1_1.Dimension); _identificationParameter1.AddLinkedParameter(_ps2_1); _ps1_2 = createParameterSelection(_simulation1, "P1_2"); _identificationParameter2.AddLinkedParameter(_ps1_2); _ps2_2 = createParameterSelection(_simulation2, "P2_2"); A.CallTo(() => _ps2_2.Dimension).Returns(_ps1_2.Dimension); _identificationParameter2.AddLinkedParameter(_ps2_2); _allVariableIdentificationParameters.Add(_identificationParameter1); _allVariableIdentificationParameters.Add(_identificationParameter2); _observedData1 = A.Fake <DataRepository>(); _observedData2 = A.Fake <DataRepository>(); _observedData3 = A.Fake <DataRepository>(); _observedData4 = A.Fake <DataRepository>(); _observedData5 = A.Fake <DataRepository>(); _residualResults.AddOutputResiduals(_output1.FullOutputPath, _observedData1, new[] { new Residual(2, 0.10, 1), new Residual(4, 0.40, 2), new Residual(6, 1.00, 1), new Residual(8, 0, 0), }); _residualResults.AddOutputResiduals(_output1.FullOutputPath, _observedData2, new[] { new Residual(6, 0.20, 2), new Residual(8, 0.80, 4), new Residual(10, -0.20, 2), new Residual(12, 0, 0), }); _residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData3, new[] { new Residual(2, 0, 0), new Residual(4, 0.20, 2), new Residual(6, -0.20, 2), new Residual(8, 0, 0), }); _residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData4, new[] { new Residual(6, 0.20, 2), new Residual(8, 0.80, 4), new Residual(10, -0.20, 2), new Residual(12, 0, 0), }); _residualResults.AddOutputResiduals(_output2.FullOutputPath, _observedData5, new[] { new Residual(6, 0, 0), new Residual(8, 0, 0), new Residual(10, 0, 0), new Residual(12, 0, 0), }); var baseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs()) { Values = new[] { 0f, 2f, 4f, 6f, 8f, 10f, 12f, 14f, 16f } }; var C1 = new DataColumn { BaseGrid = baseGrid, Values = new[] { 0f, 0.71f, 2.10f, 3.14f, 3.76f, 4.04f, 4.12f, 4.09f, 4.02f } }; A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output1.FullOutputPath)).Returns(C1); var C2 = new DataColumn { BaseGrid = baseGrid, Values = new[] { 0f, 0.37f, 0.38f, 0.31f, 0.23f, 0.17f, 0.14f, 0.12f, 0.11f } }; A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output2.FullOutputPath)).Returns(C2); var C3 = new DataColumn { BaseGrid = baseGrid, Values = new[] { 0f, 0.53f, 0.54f, 0.43f, 0.32f, 0.25f, 0.20f, 0.17f, 0.16f } }; A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output3.FullOutputPath)).Returns(C3); var C4 = new DataColumn { BaseGrid = baseGrid, Values = new[] { 0f, 0.16f, 0.16f, 0.13f, 0.10f, 0.07f, 0.06f, 0.05f, 0.05f } }; A.CallTo(() => _runResult.BestResult.SimulationResultFor(_output4.FullOutputPath)).Returns(C4); var covarianceMatrix = new Matrix(parameterNames, parameterNames); A.CallTo(() => _matrixCalculator.CovarianceMatrixFrom(_runResult.JacobianMatrix, _residualResults)).Returns(covarianceMatrix); covarianceMatrix.SetRow(0, new[] { 5.05, -1.22 }); covarianceMatrix.SetRow(1, new[] { -1.22, 0.51 }); _runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output1.FullOutputPath, parameterNames, new[] { new[] { 0d, 0d }, new[] { 1d, 2d }, new[] { 2d, 3d }, new[] { 1d, 1d }, new[] { 0.5d, 0.7d }, new[] { 0.4d, 0.5d }, new[] { 0.3d, 0.5d }, new[] { 0.3d, 0.2d }, new[] { 0.1d, 0.2d } })); _runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output2.FullOutputPath, parameterNames, new[] { new[] { 0d, 0d }, new[] { -1d, -2d }, new[] { -1d, -2d }, new[] { -0.5d, -1d }, new[] { 0.1d, 0.1d }, new[] { -0.1d, -0.1d }, new[] { 0.2d, 0.2d }, new[] { 0.3d, 0.3d }, new[] { 0.2d, 0.2d } })); _runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output3.FullOutputPath, parameterNames, new[] { new[] { 0d, 0d }, new[] { 1d, 2d }, new[] { 2d, 3d }, new[] { 1d, 1d }, new[] { 0.5d, 0.7d }, new[] { 0.4d, 0.5d }, new[] { 0.3d, 0.5d }, new[] { 0.3d, 0.2d }, new[] { 0.1d, 0.2d }, })); _runResult.JacobianMatrix.AddPartialDerivatives(createPartialDerivatives(_output4.FullOutputPath, parameterNames, new[] { new[] { 0d, 0d }, new[] { -4d, -4d }, new[] { -3d, -3d }, new[] { -2d, -2d }, new[] { -1d, -1d }, new[] { -0.5d, -0.5d }, new[] { -0.4d, -0.4d }, new[] { -0.3d, -0.3d }, new[] { -0.2d, -0.2d }, })); _confidenceIntervals = new Cache <string, double[]>(); A.CallTo(() => _dataRepositoryCreator.CreateFor(A <string> ._, A <double[]> ._, A <OutputMapping> ._, A <OptimizationRunResult> ._)) .Invokes(x => { _confidenceIntervals.Add(x.GetArgument <OutputMapping>(2).FullOutputPath, x.GetArgument <double[]>(1)); }) .Returns(new DataRepository()); }
protected override void Because() { _result = sut.Run(_cancellationToken); }
private bool runShouldBeKept(ParameterIdentificationRunResult runResult) { return(runResult != null && runResult.Status.IsOneOf(RunStatus.RanToCompletion, RunStatus.Canceled)); }
public void Edit(ParameterIdentificationRunResult runResult) { _allProperties.Clear(); mapProperties(runResult); _view.BindTo(_allProperties); }
protected override void AddRunResultToChart(ParameterIdentificationRunResult runResult) { runResult.BestResult.AllOutputResiduals.GroupBy(x => x.FullOutputPath).Each(x => addOutputToScatter(x, runResult)); }
private void addOutputToScatter(IGrouping <string, OutputResiduals> outputMappingsByOutput, ParameterIdentificationRunResult runResult) { var fullOutputPath = outputMappingsByOutput.Key; bool shouldShowInLegend = true; foreach (var outputMapping in outputMappingsByOutput) { var dataRepository = getOrCreateScatterDataRepositoryFor(runResult.Index, outputMapping); AddResultRepositoryToEditor(dataRepository); var visibleInLegend = shouldShowInLegend; AddCurvesFor(dataRepository, (column, curve) => { SelectColorForPath(fullOutputPath); UpdateColorForPath(curve, fullOutputPath); curve.Name = fullOutputPath; curve.Description = CurveDescription(outputMapping.ObservedDataName, runResult); curve.Symbol = Symbols.Circle; curve.LineStyle = LineStyles.None; curve.VisibleInLegend = visibleInLegend; }); shouldShowInLegend = false; } }
public override void GlobalContext() { base.GlobalContext(); _observedData = DomainHelperForSpecs.ObservedData(); _sim1 = new IndividualSimulation { Id = "Sim1", Name = "Sim1", IsLoaded = true, Model = new Model { Root = new Container() } }; _sim1.Model.Root.Add(new Container { new Parameter().WithName("P") }.WithName("Liver")); _sim2 = new IndividualSimulation { Id = "Sim2", Name = "Sim2", IsLoaded = true, Model = new Model { Root = new Container() } }; _sim2.Model.Root.Add(new Container { new Parameter().WithName("P") }.WithName("Liver")); _objectBaseRepository = IoC.Resolve <IWithIdRepository>(); var workspace = IoC.Resolve <ICoreWorkspace>(); _project = IoC.Resolve <PKSimProject>(); workspace.Project = _project; _objectBaseRepository.Register(_sim1); _objectBaseRepository.Register(_sim2); _project.AddObservedData(_observedData); _project.AddBuildingBlock(_sim1); _project.AddBuildingBlock(_sim2); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.AddSimulation(_sim1); _parameterIdentification.AddSimulation(_sim2); _outputMapping = new OutputMapping { WeightedObservedData = new WeightedObservedData(_observedData), OutputSelection = new SimulationQuantitySelection(_sim1, new QuantitySelection("A|B", QuantityType.Metabolite)), Weight = 5, Scaling = Scalings.Log }; _outputMapping.WeightedObservedData.Weights[1] = 10; _parameterIdentification.AddOutputMapping(_outputMapping); _identificationParameter = DomainHelperForSpecs.IdentificationParameter(min: 1, max: 10, startValue: 5); _parameterSelection1 = new ParameterSelection(_sim1, new QuantitySelection("Liver|P", QuantityType.Parameter)); _parameterSelection2 = new ParameterSelection(_sim2, new QuantitySelection("Liver|P", QuantityType.Parameter)); _identificationParameter.AddLinkedParameter(_parameterSelection1); _identificationParameter.AddLinkedParameter(_parameterSelection2); _parameterIdentification.AddIdentificationParameter(_identificationParameter); _identificationParameter.Scaling = Scalings.Linear; _parameterIdentification.Configuration.AlgorithmProperties = new OptimizationAlgorithmProperties("AA"); _parameterIdentification.AlgorithmProperties.Add(new ExtendedProperty <double> { Name = "Toto", Value = 5 }); _runResult = new ParameterIdentificationRunResult(); _parameterIdentification.AddResult(_runResult); _parameterIdentification.AddAnalysis(new ParameterIdentificationPredictedVsObservedChart()); _parameterIdentification.AddAnalysis(new ParameterIdentificationTimeProfileChart()); _parameterIdentification.AddAnalysis(new ParameterIdentificationResidualHistogram()); _parameterIdentification.AddAnalysis(new ParameterIdentificationResidualVsTimeChart()); GlobalBecause(); }