protected T AnalysisFor <T>(IAnalysable analysable) where T : ISimulationAnalysis, new()
{
var analysis = new T().WithId(_idGenerator.NewId());
AddSimulationAnalysisTo(analysable, analysis);
return(analysis);
}
public void InitializeAnalysis(ISimulationAnalysis simulationAnalysis, IAnalysable analysable)
{
UpdateAnalysisBasedOn(analysable);
_matrix = simulationAnalysis.DowncastTo <TMatrix>();
_view.Caption = _matrix.Name;
UpdateAnalysis();
}
public void UpdateAnalysisBasedOn(IAnalysable analysable)
{
var simulation = analysable.DowncastTo <IndividualSimulation>();
UpdateAnalysisBasedOn(simulation);
UpdateTemplatesBasedOn(simulation);
InitializeFromTemplateIfRequired();
}
public void InitializeAnalysis(ISimulationAnalysis simulationAnalysis, IAnalysable analysable)
{
Chart = simulationAnalysis.DowncastTo <SensitivityAnalysisPKParameterAnalysis>();
setViewCaption();
AddChartEventHandlers();
UpdateAnalysisBasedOn(analysable);
ActivePKParameter = Chart.PKParameterName ?? AllPKParameters.FirstOrDefault();
ActiveOutput = Chart.OutputPath ?? AllOutputPaths.FirstOrDefault();
_view.BindTo(this);
}
public void AddSimulationAnalysisTo(IAnalysable analysable, ISimulationAnalysis simulationAnalysis)
{
if (simulationAnalysis == null)
{
return;
}
var defaultAnalysisName = string.IsNullOrEmpty(simulationAnalysis.Name) ? DefaultAnalysisNameFor(simulationAnalysis) : simulationAnalysis.Name;
simulationAnalysis.Name = _containerTask.CreateUniqueName(analysable.Analyses, defaultAnalysisName, canUseBaseName: true);
analysable.AddAnalysis(simulationAnalysis);
_executionContext.PublishEvent(new SimulationAnalysisCreatedEvent(analysable, simulationAnalysis));
}
public SimulationAnalysisWorkflow MapFrom(IAnalysable populationDataCollector)
{
var populationAnalysisWorkflow = new SimulationAnalysisWorkflow();
populationDataCollector.Analyses.Each(populationAnalysisWorkflow.Add);
var populationSimulation = populationDataCollector as PopulationSimulation;
if (populationSimulation != null)
{
populationAnalysisWorkflow.OutputSelections = populationSimulation.OutputSelections;
}
return(populationAnalysisWorkflow);
}
public void UpdateAnalysisBasedOn(IAnalysable analysable)
{
_parameterIdentification = analysable.DowncastTo <ParameterIdentification>();
AllRunResults = _parameterIdentification.Results.OrderBy(x => x.TotalError).ToList();
_view.CanSelectRunResults = AllRunResults.Count > 1;
if (!AllRunResults.Any())
{
return;
}
SelectedRunResults = AllRunResults.First();
_view.BindToSelectedRunResult();
}
public void AddObservedDataToAnalysable(DataRepository observedData, IAnalysable analysable, bool showData)
{
var simulation = analysable as Simulation;
if (simulation == null)
{
return;
}
if (simulation.UsesObservedData(observedData))
{
return;
}
simulation.AddUsedObservedData(observedData);
_executionContext.PublishEvent(new ObservedDataAddedToAnalysableEvent(simulation, observedData, showData));
_executionContext.PublishEvent(new SimulationStatusChangedEvent(simulation));
}
private void AddAnalysable(IAnalysable analysable)
{
if (analysable == null)
{
return;
}
lock (_analysableEndpoints)
_analysableEndpoints.Add(analysable);
lock (_endpointStatistics)
{
foreach (var stat in analysable.AvailableStatistics)
{
_endpointStatistics.Add(stat.Id, analysable);
}
}
}
private void AddAnalysable(IAnalysable analysable)
{
if (analysable == null)
{
return;
}
foreach (var statistic in analysable.AvailableStatistics)
{
var s = statistic;
_endpointStatistics.Add(
statistic.Id,
new EndpointStatistic
{
Statistic = statistic,
GetStatistic = () => analysable.GetStatistic(s.Id)
});
}
}
public override void UpdateAnalysisBasedOn(IAnalysable analysable)
{
_parameterIdentification = analysable.DowncastTo <ParameterIdentification>();
if (ChartIsBeingUpdated)
{
UpdateTemplateFromChart();
ClearChartAndDataRepositories();
}
else
{
updateCacheColor();
}
if (_parameterIdentification.Results.Any())
{
_isMultipleRun = _parameterIdentification.Results.Count > 1;
UpdateAnalysisBasedOn(_parameterIdentification.Results);
}
Refresh();
}
public SimulationAnalysisCreatedEvent(IAnalysable analysable, ISimulationAnalysis simulationAnalysis) : base(analysable)
{
SimulationAnalysis = simulationAnalysis;
}
public virtual void InitializeAnalysis(ISimulationAnalysis simulationAnalysis, IAnalysable analysable)
{
try
{
_isInitializing = true;
base.InitializeAnalysis(simulationAnalysis.DowncastTo <TChart>());
_chartIsNew = !Chart.Curves.Any();
UpdateAnalysisBasedOn(analysable);
}
finally
{
_isInitializing = false;
}
}
public void InitializeAnalysis(ISimulationAnalysis simulationAnalysis, IAnalysable analysable)
{
base.InitializeAnalysis(simulationAnalysis.DowncastTo <SimulationTimeProfileChart>());
UpdateAnalysisBasedOn(analysable);
}
public abstract void UpdateAnalysisBasedOn(IAnalysable analysable);
public void UpdateAnalysisBasedOn(IAnalysable analysable)
{
_sensitivityAnalysis = analysable.DowncastTo <SensitivityAnalysis>();
}
public static void UpdateColumnSettings(this IQuantityPresenter quantityPresenter, IAnalysable analysable)
{
//update default captions
if (!analysable.ComesFromPKSim)
{
return;
}
quantityPresenter.SetCaption(PathElementId.Simulation, Captions.Simulation);
quantityPresenter.SetCaption(PathElementId.TopContainer, Captions.Organism);
quantityPresenter.SetCaption(PathElementId.Container, Captions.Organ);
quantityPresenter.SetCaption(PathElementId.BottomCompartment, Captions.Compartment);
quantityPresenter.SetCaption(PathElementId.Molecule, Captions.Molecule);
quantityPresenter.SetCaption(PathElementId.Name, Captions.Name);
quantityPresenter.GroupBy(PathElementId.Container);
quantityPresenter.SortColumn(PathElementId.BottomCompartment);
quantityPresenter.Hide(PathElementId.Simulation);
quantityPresenter.Hide(PathElementId.TopContainer);
quantityPresenter.Hide(QuantityColumn.QuantityType);
quantityPresenter.Hide(QuantityColumn.Dimension);
}
public void InitializeAnalysis(ISimulationAnalysis simulationAnalysis, IAnalysable analysable)
{
PopulationAnalysisChart = simulationAnalysis.DowncastTo <TPopulationAnalysisChart>();
updateCaption();
UpdateAnalysisBasedOn(analysable);
}
public void UpdateAnalysisBasedOn(IAnalysable analysable)
{
UpdateAnalysisBasedOn(analysable.DowncastTo <IPopulationDataCollector>());
}
protected AnalysableEvent(IAnalysable analysable)
{
Analysable = analysable;
}
public ObservedDataAddedToAnalysableEvent(IAnalysable analysable, DataRepository observedData, bool showData) : this(analysable, new[] { observedData }, showData)
{
}
public void AddObservedDataToAnalysable(IReadOnlyList <DataRepository> observedData, IAnalysable analysable)
{
AddObservedDataToAnalysable(observedData, analysable, showData: false);
}
public ObservedDataRemovedFromAnalysableEvent(IAnalysable analysable, IReadOnlyList <DataRepository> observedData) : base(analysable)
{
ObservedData = observedData;
}
public ObservedDataRemovedFromAnalysableEvent(IAnalysable analysable, DataRepository observedData) : this(analysable, new[] { observedData })
{
}
public ObservedDataAddedToAnalysableEvent(IAnalysable analysable, IReadOnlyList <DataRepository> observedData, bool showData) : base(analysable)
{
ObservedData = observedData;
ShowData = showData;
}
public void AddObservedDataToAnalysable(IReadOnlyList <DataRepository> observedData, IAnalysable analysable)
{
_observedDataTask.AddObservedDataToAnalysable(observedData, analysable);
}
public void AddObservedDataToAnalysable(DataRepository observedData, IAnalysable analysable)
{
AddObservedDataToAnalysable(observedData, analysable, showData: false);
}
public void AddObservedDataToAnalysable(IReadOnlyList <DataRepository> observedData, IAnalysable analysable, bool showData)
{
var simulation = analysable as Simulation;
if (simulation == null)
{
return;
}
var observedDataToAdd = observedData.Where(x => !simulation.UsesObservedData(x)).ToList();
if (!observedDataToAdd.Any())
{
return;
}
observedDataToAdd.Each(simulation.AddUsedObservedData);
_executionContext.PublishEvent(new ObservedDataAddedToAnalysableEvent(simulation, observedDataToAdd, showData));
_executionContext.PublishEvent(new SimulationStatusChangedEvent(simulation));
}
public void AddObservedDataToAnalysable(DataRepository observedData, IAnalysable analysable)
{
_observedDataTask.AddObservedDataToAnalysable(observedData, analysable);
}
