private Task <IndividualSimulationComparison> createIndividualComparisonModel(SimulationComparison snapshot, PKSimProject project)
{
var simulationComparisonContext = new SimulationAnalysisContext(project.AllObservedData);
var comparedSimulations = allComparedSimulationsFrom <IndividualSimulation>(snapshot, project);
comparedSimulations.Each(s => simulationComparisonContext.AddDataRepository(s.DataRepository));
return(_individualSimulationComparisonMapper.MapToModel(snapshot.IndividualComparison, simulationComparisonContext));
}
private async Task updatePopulationComparisonModel(PopulationSimulationComparison populationSimulationComparison, SimulationComparison snapshot, PKSimProject project)
{
var simulationComparisonContext = new SimulationAnalysisContext(project.AllObservedData);
var allPopulationAnalysis = await _populationAnalysisChartMapper.MapToModels(snapshot.PopulationComparisons, simulationComparisonContext);
allPopulationAnalysis?.Each(populationSimulationComparison.AddAnalysis);
populationSimulationComparison.ReferenceGroupingItem = snapshot.ReferenceGroupingItem;
populationSimulationComparison.ReferenceSimulation = project.BuildingBlockByName <PopulationSimulation>(snapshot.ReferenceSimulation);
}
private Task <TAnalysis[]> analysesFrom <TAnalysis, TSnapshotAnalysis>(ModelSimulation simulation, TSnapshotAnalysis[] snapshotAnalyses, PKSimProject project,
Func <TSnapshotAnalysis[], SimulationAnalysisContext, Task <TAnalysis[]> > mapFunc)
{
if (snapshotAnalyses == null)
{
return(Task.FromResult(new List <TAnalysis>().ToArray()));
}
var curveChartContext = new SimulationAnalysisContext(project.AllObservedData);
var individualSimulation = simulation as IndividualSimulation;
if (individualSimulation?.DataRepository != null)
{
curveChartContext.AddDataRepository(individualSimulation.DataRepository);
}
return(mapFunc(snapshotAnalyses, curveChartContext));
}
public override async Task <ISimulationAnalysis> MapToModel(ParameterIdentificationAnalysis snapshot, ParameterIdentificationContext snapshotContext)
{
var simulationAnalysis = createAnalysisFrom(snapshot.Type);
if (simulationAnalysis != null)
{
simulationAnalysis.Id = _idGenerator.NewId();
}
else
{
var localDataRepositories = await _dataRepositoryMapper.MapToModels(snapshot.DataRepositories, snapshotContext);
var simulationAnalysisContext = new SimulationAnalysisContext(localDataRepositories, snapshotContext);
simulationAnalysisContext.AddDataRepositories(snapshotContext.Project.AllDataRepositories());
_parameterIdentificationAnalysisChartMapper.ChartFactoryFunc = () => createChartFrom(snapshot.Type);
simulationAnalysis = await _parameterIdentificationAnalysisChartMapper.MapToModel(snapshot.Chart, simulationAnalysisContext);
}
MapSnapshotPropertiesToModel(snapshot, simulationAnalysis);
return(simulationAnalysis);
}
private async Task updateChartCurves(ModelCurveChart curveChart, IReadOnlyList <Curve> snapshotCurves, SimulationAnalysisContext simulationAnalysisContext)
{
var curves = await _curveMapper.MapToModels(snapshotCurves, simulationAnalysisContext);
curves?.Each(x => curveChart.AddCurve(x, useAxisDefault: false));
}
public override async Task <TCurveChart> MapToModel(SnapshotCurveChart snapshot, SimulationAnalysisContext simulationAnalysisContext)
{
var curveChart = ChartFactoryFunc().WithId(_idGenerator.NewId());
MapSnapshotPropertiesToModel(snapshot, curveChart);
await _chartMapper.MapToModel(snapshot, new ChartSnapshotContext(curveChart, simulationAnalysisContext));
await updateChartAxes(curveChart, snapshot.Axes, simulationAnalysisContext);
await updateChartCurves(curveChart, snapshot.Curves, simulationAnalysisContext);
return(curveChart);
}