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