-
Notifications
You must be signed in to change notification settings - Fork 49
/
SimulationTask.cs
177 lines (153 loc) · 9.53 KB
/
SimulationTask.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
using System.Linq;
using PKSim.Assets;
using OSPSuite.Core.Commands.Core;
using PKSim.Core;
using PKSim.Core.Commands;
using PKSim.Core.Model;
using PKSim.Core.Services;
using PKSim.Presentation.Presenters.Simulations;
using OSPSuite.Core.Comparison;
using OSPSuite.Core.Domain;
using OSPSuite.Core.Domain.Data;
using OSPSuite.Presentation.Core;
using PKSim.Core.Events;
namespace PKSim.Presentation.Services
{
public interface ISimulationTask : IBuildingBlockTask<Simulation>
{
/// <summary>
/// update the given template building block into the simulation
/// </summary>
/// <typeparam name="TBuildingBlock">Type of building block</typeparam>
/// <param name="templateBuildingBlock">Template building block used as source of the update</param>
/// <param name="usedBuildingBlock">used building block whose value/structure will be updated</param>
/// <param name="simulation">simulation containing the used building block</param>
void UpdateUsedBuildingBlockInSimulation<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock;
/// <summary>
/// Save the change made in the used building block belonging in the simulation into the given template building block
/// </summary>
/// <typeparam name="TBuildingBlock">Type of building block</typeparam>
/// <param name="templateBuildingBlock">Template building block that will be updated</param>
/// <param name="usedBuildingBlock">used building block from which the values will be taken</param>
/// <param name="simulation">simulation containing the used building block</param>
void CommitBuildingBlockToRepository<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock;
/// <summary>
/// Shows the difference between the template building block and the building block used in the simulation
/// </summary>
/// <typeparam name="TBuildingBlock">Type of building block</typeparam>
/// <param name="templateBuildingBlock">Template building block </param>
/// <param name="usedBuildingBlock">used building block</param>
/// <param name="simulation">containing the used building block</param>
void ShowDifferencesBetween<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock;
/// <summary>
/// Import external results into simulation (for example from cluster export)
/// </summary>
/// <param name="populationSimulation">PopulationSimulation for which results should be imported</param>
void ImportResultsIn(PopulationSimulation populationSimulation);
/// <summary>
/// Import external PK-Analyses into simulation (for example from matlab user defined scripts)
/// </summary>
/// <param name="populationSimulation">PopulationSimulation for which pk-analyses should be imported</param>
void ImportPKAnalyses(PopulationSimulation populationSimulation);
}
public class SimulationTask : BuildingBlockTask<Simulation>, ISimulationTask
{
private readonly ISimulationBuildingBlockUpdater _simulationBuildingBlockUpdater;
private readonly IConfigureSimulationTask _configureSimulationTask;
private readonly IBuildingBlockParametersToSimulationUpdater _blockParametersToSimulationUpdater;
private readonly ISimulationParametersToBuildingBlockUpdater _simulationParametersToBlockUpdater;
public SimulationTask(
IExecutionContext executionContext,
IBuildingBlockTask buildingBlockTask,
IApplicationController applicationController,
ISimulationBuildingBlockUpdater simulationBuildingBlockUpdater,
IConfigureSimulationTask configureSimulationTask,
IBuildingBlockParametersToSimulationUpdater blockParametersToSimulationUpdater,
ISimulationParametersToBuildingBlockUpdater simulationParametersToBlockUpdater)
: base(executionContext, buildingBlockTask, applicationController, PKSimBuildingBlockType.Simulation)
{
_simulationBuildingBlockUpdater = simulationBuildingBlockUpdater;
_configureSimulationTask = configureSimulationTask;
_blockParametersToSimulationUpdater = blockParametersToSimulationUpdater;
_simulationParametersToBlockUpdater = simulationParametersToBlockUpdater;
}
public override Simulation AddToProject()
{
var simulation = AddToProject<ICreateSimulationPresenter>();
if (simulation == null)
return null;
//after creation => we go in edit mode
Edit(simulation);
return simulation;
}
public void UpdateUsedBuildingBlockInSimulation<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock
{
_buildingBlockTask.Load(templateBuildingBlock);
_buildingBlockTask.Load(simulation);
//Now that the simulation is loaded, we want to make sure that the captured ref to used building block also has a valid reference to the underlying building block
var loadedUsedBuildingBlock = simulation.UsedBuildingBlockByTemplateId(usedBuildingBlock.TemplateId);
//check if quick update possible. if yes =>perform quick update
if (_simulationBuildingBlockUpdater.QuickUpdatePossibleFor(templateBuildingBlock, loadedUsedBuildingBlock))
{
var updateCommand = _blockParametersToSimulationUpdater.UpdateParametersFromBuildingBlockInSimulation(templateBuildingBlock, simulation);
_buildingBlockTask.AddCommandToHistory(updateCommand);
}
else
//we have to start the configuration workflow
_configureSimulationTask.Configure(simulation, templateBuildingBlock);
//In any case, publish a simulation updated event to notify that a simulation was updated from building block
_executionContext.PublishEvent(new SimulationUpdatedEvent(simulation));
}
public void CommitBuildingBlockToRepository<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock
{
_buildingBlockTask.Load(templateBuildingBlock);
_buildingBlockTask.Load(simulation);
//Now that the simulation is loaded, we want to make sure that the captured ref to used building block also has a valid reference to the underlying building block
var loadedUsedBuildingBlock = simulation.UsedBuildingBlockByTemplateId(usedBuildingBlock.TemplateId);
//check if quick update possible. if yes =>perform quick update
if (_simulationBuildingBlockUpdater.QuickUpdatePossibleFor(templateBuildingBlock, loadedUsedBuildingBlock))
{
var updateCommand = _simulationParametersToBlockUpdater.UpdateParametersFromSimulationInBuildingBlock(simulation, templateBuildingBlock);
_buildingBlockTask.AddCommandToHistory(updateCommand);
}
else
throw new PKSimException(PKSimConstants.Error.AdvancedCommitNotAvailable);
}
public void ShowDifferencesBetween<TBuildingBlock>(TBuildingBlock templateBuildingBlock, UsedBuildingBlock usedBuildingBlock, Simulation simulation) where TBuildingBlock : class, IPKSimBuildingBlock
{
_buildingBlockTask.Load(templateBuildingBlock);
_buildingBlockTask.Load(simulation);
if (!_simulationBuildingBlockUpdater.BuildingBlockSupportComparison(templateBuildingBlock))
throw new PKSimException(PKSimConstants.Error.ComparisonWithTemplateNotSupportedForBuildingBlockOfType(_executionContext.TypeFor(templateBuildingBlock)));
//Uses the UsedBuildingBlockById since the usedBuildingBlock might have been lazy loaded
var simulationBuildingBlock = simulation.UsedBuildingBlockById(usedBuildingBlock.Id).BuildingBlock;
_executionContext.PublishEvent(new StartComparisonEvent(
leftObject: templateBuildingBlock,
leftCaption: PKSimConstants.UI.BuildingBlock,
rightObject: simulationBuildingBlock,
rightCaption: PKSimConstants.ObjectTypes.Simulation));
}
public void ImportResultsIn(PopulationSimulation populationSimulation)
{
_buildingBlockTask.Load(populationSimulation);
using (var presenter = _applicationController.Start<IImportSimulationResultsPresenter>())
{
var simulationResults = presenter.ImportResultsFor(populationSimulation);
if (simulationResults.IsNull())
return;
_buildingBlockTask.AddCommandToHistory(new SetPopulationSimulationResultsCommand(populationSimulation, simulationResults).Run(_executionContext));
}
}
public void ImportPKAnalyses(PopulationSimulation populationSimulation)
{
_buildingBlockTask.Load(populationSimulation);
using (var presenter = _applicationController.Start<IImportSimulationPKAnalysesPresenter>())
{
var pkAnalyses = presenter.ImportPKAnalyses(populationSimulation);
if (!pkAnalyses.Any())
return;
_buildingBlockTask.AddCommandToHistory(new AddPKAnalysesToSimulationCommand(populationSimulation, pkAnalyses, presenter.FileName).Run(_executionContext));
}
}
}
}