protected override Task Context()
{
_individualSimulationComparisonMapper = A.Fake <IndividualSimulationComparisonMapper>();
_populationAnalysisChartMapper = A.Fake <PopulationAnalysisChartMapper>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
sut = new SimulationComparisonMapper(_individualSimulationComparisonMapper, _populationAnalysisChartMapper, _objectBaseFactory);
_individualSimulation1 = new IndividualSimulation().WithName("IndS1").WithId("IndS1");
_individualSimulation2 = new IndividualSimulation().WithName("IndS2").WithId("IndS2");
_individualSimulationComparison = new IndividualSimulationComparison
{
Name = "IndividualComparison",
Description = "IndividualComparison Description",
};
_individualSimulationComparison.AddSimulation(_individualSimulation1);
_individualSimulationComparison.AddSimulation(_individualSimulation2);
_populationSimulation1 = new PopulationSimulation().WithName("PopS1").WithId("PopS1");
_populationSimulation2 = new PopulationSimulation().WithName("PopS2").WithId("PopS2");
_referenceSimulation = new PopulationSimulation().WithName("PopS3").WithId("PopS3");
_populationSimulationComparison = new PopulationSimulationComparison
{
Name = "PopulationComparison",
Description = "PopulationComparison Description",
};
_populationSimulationAnalysis = new BoxWhiskerAnalysisChart();
_populationSimulationComparison.AddSimulation(_populationSimulation1);
_populationSimulationComparison.AddSimulation(_populationSimulation2);
_populationSimulationComparison.AddAnalysis(_populationSimulationAnalysis);
_populationSimulationComparison.ReferenceGroupingItem = new GroupingItem();
_populationSimulationComparison.ReferenceSimulation = _referenceSimulation;
_curveChart = new CurveChart();
A.CallTo(() => _individualSimulationComparisonMapper.MapToSnapshot(_individualSimulationComparison)).Returns(_curveChart);
_populationAnalysisChartSnapshot = new Snapshots.PopulationAnalysisChart();
A.CallTo(() => _populationAnalysisChartMapper.MapToSnapshot(_populationSimulationAnalysis)).Returns(_populationAnalysisChartSnapshot);
_project = new PKSimProject();
_project.AddBuildingBlock(_individualSimulation1);
_project.AddBuildingBlock(_individualSimulation2);
_project.AddBuildingBlock(_populationSimulation1);
_project.AddBuildingBlock(_populationSimulation2);
_project.AddBuildingBlock(_referenceSimulation);
return(_completed);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <IndividualSimulation>();
_dataTables = new List <DataTable>();
A.CallTo(() => _simulation.HasResults).Returns(true);
A.CallTo(() => _simulation.Name).Returns("toto");
A.CallTo(() => _simulation.DataRepository).Returns(new DataRepository());
_excelFile = "tralala";
A.CallTo(() => _dialogCreator.AskForFileToSave(PKSimConstants.UI.ExportSimulationResultsToExcel, Constants.Filter.EXCEL_SAVE_FILE_FILTER, Constants.DirectoryKey.REPORT, CoreConstants.DefaultResultsExportNameFor(_simulation.Name), null)).Returns(_excelFile);
}
public Task ExportResultsToExcelAsync(IndividualSimulation individualSimulation)
{
_lazyLoadTask.LoadResults(individualSimulation);
if (!individualSimulation.HasResults)
{
throw new PKSimException(PKSimConstants.Error.CannotExportResultsPleaseRunSimulation(individualSimulation.Name));
}
return(exportToFileAsync(PKSimConstants.UI.ExportSimulationResultsToExcel, Constants.Filter.EXCEL_SAVE_FILE_FILTER, CoreConstants.DefaultResultsExportNameFor(individualSimulation.Name),
fileName => ExportResultsToExcelAsync(individualSimulation, fileName), Constants.DirectoryKey.REPORT));
}
private void renameIndividualSimulation(IndividualSimulation individualSimulation, string newName)
{
var individualSimulationDataRepository = individualSimulation.DataRepository;
if (individualSimulationDataRepository != null)
{
_dataRepositoryNamer.Rename(individualSimulationDataRepository, newName);
}
renameSimulation(individualSimulation, newName);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <IndividualSimulation>();
_observedData = A.Fake <DataRepository>();
_chart = new SimulationTimeProfileChart();
_chart.AddObservedData(_observedData);
sut.InitializeAnalysis(_chart);
sut.UpdateAnalysisBasedOn(_simulation);
_view.Caption = "OLD_NAME";
}
protected override async Task Context()
{
await base.Context();
_simulation = A.Fake <IndividualSimulation>();
A.CallTo(() => _simulation.Analyses).Returns(new List <ISimulationAnalysis> {
A.Fake <ISimulationAnalysis>()
});
A.CallTo(() => _simulation.HasResults).Returns(true);
await sut.RunSimulation(_simulation, false);
}
public override void GlobalContext()
{
base.GlobalContext();
LoadProject("Population_Individual_603");
_population = First <RandomPopulation>();
_individual = First <Individual>();
_indSimulation = First <IndividualSimulation>();
_popSimulation = First <PopulationSimulation>();
_formulation = First <Formulation>();
}
protected override void Context()
{
_objectPathFactory = new ObjectPathFactoryForSpecs();
_dataColumnToPathElementsMapper = A.Fake<IDataColumnToPathElementsMapper>();
_pathToPathElementsMapper = A.Fake<IPathToPathElementsMapper>();
sut = new PKSimQuantityPathToQuantityDisplayPathMapper(_objectPathFactory, _pathToPathElementsMapper, _dataColumnToPathElementsMapper);
_root = new Container().WithName("ROOT");
var baseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs());
_column = new DataColumn("Conc", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), baseGrid);
_individualSimulation = new IndividualSimulation {Model = new Model {Root = _root}};
}
private IParameter fractionAbsorbedFor(IndividualSimulation simulation, string compoundName)
{
var fabsOralObserver = simulation.DataRepository.FabsOral(compoundName);
double?fractionAbsorbedValue = null;
if (fabsOralObserver != null)
{
fractionAbsorbedValue = fabsOralObserver.Values.Last();
}
return(createParameter(CoreConstants.PKAnalysis.FractionAbsorbed, fractionAbsorbedValue, CoreConstants.Dimension.Fraction));
}
protected override void Context()
{
_simulation = new IndividualSimulation {
DataRepository = new DataRepository(), SimulationSettings = new SimulationSettings()
};
_defaultChartTemplate = new CurveChartTemplate {
IsDefault = false
};
_simulation.SimulationSettings.AddChartTemplate(_defaultChartTemplate);
base.Context();
sut.InitializeAnalysis(new SimulationTimeProfileChart());
}
private void removeSimulation(IndividualSimulation simulation)
{
var repo = DataRepositoryFor(simulation);
if (repo == null)
{
return;
}
_repositoryCache.Remove(repo);
_chartEditorPresenter.RemoveDataRepository(repo);
Chart.RemoveSimulation(simulation);
}
private Simulation createSimulationWithResults(string simulationName)
{
var simulation = new IndividualSimulation
{
Name = simulationName,
SimulationSettings = new SimulationSettings(),
DataRepository = DomainHelperForSpecs.IndividualSimulationDataRepositoryFor(simulationName)
};
simulation.OutputSelections.AddOutput(new QuantitySelection("C", QuantityType.Drug));
return(simulation);
}
protected override async Task Context()
{
await base.Context();
_simulation = new IndividualSimulation().WithName("S");
_qualificationStep = new RunSimulationQualificationStep {
Simulation = _simulation
};
_snapshot = await sut.MapToSnapshot(_qualificationStep);
_project.AddBuildingBlock(_simulation);
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <IndividualSimulation>();
var dimension = A.Fake <IDimension>();
_compound = A.Fake <Compound>();
A.CallTo(() => _compound.Name).Returns("Drug");
//new data repository + columns
_newDataRepository = new DataRepository();
_newBaseGrid = new BaseGrid("baseGrid1", "baseGrid1", dimension);
_newBaseGrid.Values = new float[] { 1, 2, 3, 4 };
_newColumn = new DataColumn("col1", "col1", dimension, _newBaseGrid);
_newColumn.Values = new float[] { 1, 1, 1, 1 };
_newColumn.QuantityInfo = new QuantityInfo("sp1", new List <string> {
"Liver", "Cell", "Drug", "Obs1"
}, QuantityType.Observer | QuantityType.Drug);
_newExistingColumn = new DataColumn("col2", "col2", dimension, _newBaseGrid);
_newExistingColumn.QuantityInfo = new QuantityInfo("sp2", new List <string> {
"Liver", "Cell", "Drug", "Obs2"
}, QuantityType.Observer | QuantityType.Metabolite);
_newExistingColumn.Values = new float[] { 2, 2, 2, 2 };
_newDataRepository.Add(_newBaseGrid);
_newDataRepository.Add(_newColumn);
_newDataRepository.Add(_newExistingColumn);
//old data repository + columns
_oldDataRepository = new DataRepository();
_oldBaseGrid = new BaseGrid("baseGrid2", "baseGrid2", dimension);
_oldBaseGrid.Values = new float[] { 1, 2, 3 };
_oldColumn = new DataColumn("col3", "col3", dimension, _oldBaseGrid);
_oldColumn.Values = new float[] { 3, 3, 3 };
_oldColumn.QuantityInfo = new QuantityInfo("sp3", new List <string> {
"Liver", "Cell", "Drug", "Obs3"
}, QuantityType.Observer | QuantityType.Drug);
_oldExistingColumn = new DataColumn("col4", "col4", dimension, _oldBaseGrid);
_oldExistingColumn.QuantityInfo = new QuantityInfo("sp2", new List <string> {
"Liver", "Cell", "Drug", "Obs2"
}, QuantityType.Observer | QuantityType.Drug);
_oldExistingColumn.Values = new float[] { 2, 2, 2 };
_oldDataRepository.Add(_oldBaseGrid);
_oldDataRepository.Add(_oldColumn);
_oldDataRepository.Add(_oldExistingColumn);
A.CallTo(() => _simulation.HasResults).Returns(true);
A.CallTo(() => _simulation.DataRepository).Returns(_oldDataRepository);
A.CallTo(() => _compound.MolWeight).Returns(20);
A.CallTo(() => _simulation.BuildingBlock <Compound>()).Returns(_compound);
}
protected override void Context()
{
base.Context();
_templateSimulation = new IndividualSimulation();
_templateSimulation.Properties = new SimulationProperties();
_templateSimulation.ModelProperties = new ModelProperties();
_templateSimulation.AddUsedBuildingBlock(new UsedBuildingBlock("templateId3", PKSimBuildingBlockType.Individual)
{
BuildingBlock = new Individual()
});
var theCompound = new Compound {
Name = "theCompound"
};
_originalCalculationMethod = new CalculationMethod();
var usedBuildingBlock = new UsedBuildingBlock("templateID", PKSimBuildingBlockType.Compound)
{
BuildingBlock = theCompound
};
var theOtherCompound = new Compound {
Name = "theOtherCompound"
};
var anotherUsedBuildingBlock = new UsedBuildingBlock("templateID2", PKSimBuildingBlockType.Compound)
{
BuildingBlock = theOtherCompound
};
_templateSimulation.AddUsedBuildingBlock(usedBuildingBlock);
_templateSimulation.AddUsedBuildingBlock(anotherUsedBuildingBlock);
_replacementCalculationMethod = new CalculationMethod();
_newCalculationMethods = new List <CalculationMethodWithCompoundName> {
new CalculationMethodWithCompoundName(_replacementCalculationMethod, "theCompound")
};
var compoundProperties = new CompoundProperties {
Compound = theCompound
};
compoundProperties.CalculationMethodCache.AddCalculationMethod(_originalCalculationMethod);
_templateSimulation.Properties.AddCompoundProperties(compoundProperties);
compoundProperties = new CompoundProperties {
Compound = theOtherCompound
};
compoundProperties.CalculationMethodCache.AddCalculationMethod(_originalCalculationMethod);
_templateSimulation.Properties.AddCompoundProperties(compoundProperties);
A.CallTo(() => _cloner.Clone(_templateSimulation)).Returns(_templateSimulation);
A.CallTo(() => _objectBaseFactory.Create <IndividualSimulation>()).ReturnsLazily(() => new IndividualSimulation());
}
public override void GlobalContext()
{
base.GlobalContext();
_fourCompSim = DomainFactoryForSpecs.CreateDefaultSimulationForModel(CoreConstants.Model.FOUR_COMP);
_fourComp = _fourCompSim.Model.Root.Container(Constants.ORGANISM);
_twoPoresSim = DomainFactoryForSpecs.CreateDefaultSimulationForModel(CoreConstants.Model.TWO_PORES);
_twoPores = _twoPoresSim.Model.Root.Container(Constants.ORGANISM);
_organisms = new List <IContainer> {
_fourComp, _twoPores
};
}
protected override void Context()
{
base.Context();
const string id = "myId";
_classifiableSimulation = new ClassifiableSimulation {
Id = id
};
sut.AddClassifiable(_classifiableSimulation);
_subject = new IndividualSimulation {
Id = id, Name = "name"
};
}
public override void GlobalContext()
{
base.GlobalContext();
LoadProject("BuildingBlockRename_611");
_iv = FindByName <Protocol>("IV");
_oral = FindByName <Protocol>("ORAL");
_s1 = FindByName <IndividualSimulation>("S1");
_s2 = FindByName <IndividualSimulation>("S2");
_s3 = FindByName <IndividualSimulation>("S3");
sut.RenameBuildingBlock(_iv, "NEW_IV");
sut.RenameBuildingBlock(_oral, "NEW_ORAL");
}
private PKAnalysis bloodPkAnalysisFor(IndividualSimulation simulation, string compoundName)
{
var peripheralVenousBloodCurve = simulation.DataRepository.PeripheralVenousBloodColumn(compoundName);
var venousBloodCurve = simulation.DataRepository.VenousBloodColumn(compoundName);
if (peripheralVenousBloodCurve == null || venousBloodCurve == null)
{
return(new PKAnalysis());
}
var bloodCurveForPKAnalysis = bloodCurveForSpecies(peripheralVenousBloodCurve, venousBloodCurve, simulation.Individual);
return(_pkAnalysisTask.CalculateFor(simulation, bloodCurveForPKAnalysis).PKAnalysis);
}
public Task ExportResultsToExcel(IndividualSimulation individualSimulation)
{
_buildingBlockTask.LoadResults(individualSimulation);
if (!individualSimulation.HasResults)
{
throw new PKSimException(PKSimConstants.Error.CannotExportResultsPleaseRunSimulation(individualSimulation.Name));
}
return(exportToFileAsync(PKSimConstants.UI.ExportSimulationResultsToExcel, Constants.Filter.EXCEL_SAVE_FILE_FILTER, PKSimConstants.UI.DefaultResultsExportNameFor(individualSimulation.Name), async fileName =>
{
var dataTables = _dataRepositoryTask.ToDataTable(individualSimulation.DataRepository, x => _quantityDisplayPathMapper.DisplayPathAsStringFor(individualSimulation, x), x => x.Dimension);
await Task.Run(() => _dataRepositoryTask.ExportToExcel(dataTables, fileName, launchExcel: true));
}, Constants.DirectoryKey.REPORT));
}
private void cloneIndividualSimulationResults(IndividualSimulation sourceSimulation, IndividualSimulation targetSimulation)
{
if (sourceSimulation.DataRepository.IsNull())
{
return;
}
//Step 1 - update the results
targetSimulation.Results = _simulationResultsCreator.CreateResultsFrom(_cloner.Clone(sourceSimulation.DataRepository));
//Step 2 - update the data repository based on the results created above
targetSimulation.DataRepository = _dataRepositoryCreator.CreateResultsFor(targetSimulation);
sourceSimulation.SimulationCharts.Each(c => targetSimulation.AddAnalysis(_chartTemplatingTask.CloneChart(c, targetSimulation)));
}
public SimulationMetaData MapFrom(IndividualSimulation simulation)
{
var simMetaData = createFor(simulation, SimulationMode.Individual);
if (!resultsHaveChanged(simulation))
{
return(simMetaData);
}
//simulation was loaded. It is necessary to update the results
var results = _simulationResultsCreator.CreateResultsFrom(simulation.DataRepository);
simMetaData.SimulationResults = results;
return(simMetaData);
}
protected override void Context()
{
base.Context();
_allAvailableColumns = A.Fake <IReadOnlyCollection <DataColumn> >();
_chartEditorPresenter = A.Fake <IChartEditorPresenter>();
var individualSimulation = new IndividualSimulation {
SimulationSettings = new SimulationSettings()
};
_simulationCollection = new List <ISimulation> {
individualSimulation
};
_chartWithObservedData = A.Fake <ChartWithObservedData>();
A.CallTo(() => _chartEditorPresenter.Chart).Returns(_chartWithObservedData);
}
protected override void Context()
{
base.Context();
_ddiRatioSimulation = new IndividualSimulation();
//Simulate calculated results by setting the DataRepository
_ddiRatioSimulation.DataRepository = _simulation.DataRepository;
_pkAnalysis = new PKAnalysis();
_pkAnalysis.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(Constants.PKParameters.C_max));
_pkAnalysis.Add(DomainHelperForSpecs.ConstantParameterWithValue(2).WithName(Constants.PKParameters.AUC_inf));
A.CallTo(() => _globalPKAnalysisRunner.RunForDDIRatio(_simulation)).Returns(_ddiRatioSimulation);
A.CallTo(() => _pkAnalysisTask.CalculateFor(_ddiRatioSimulation, _peripheralVenousBloodPlasma)).Returns(new IndividualPKAnalysis(_peripheralVenousBloodPlasma, _pkAnalysis));
}
public override void GlobalContext()
{
base.GlobalContext();
_iv = FindByName <Protocol>("IV");
_oral = FindByName <Protocol>("ORAL");
_s1 = FindByName <IndividualSimulation>("S1");
_s2 = FindByName <IndividualSimulation>("S2");
_s3 = FindByName <IndividualSimulation>("S3");
_iv.Name = "NEW_IV";
sut.RenameUsageOfBuildingBlockInProject(_iv, "IV");
_oral.Name = "NEW_ORAL";
sut.RenameUsageOfBuildingBlockInProject(_oral, "ORAL");
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <IndividualSimulation>();
_observedData = A.Fake <DataRepository>();
_chart = new SimulationTimeProfileChart();
_chart.AddObservedData(_observedData);
sut.InitializeAnalysis(_chart);
sut.UpdateAnalysisBasedOn(_simulation);
_dataRepositoriesRemoved = new List <DataRepository>();
A.CallTo(() => _chartEditorPresenter.RemoveDataRepositories(A <IEnumerable <DataRepository> > ._))
.Invokes(x => _dataRepositoriesRemoved.AddRange(x.GetArgument <IEnumerable <DataRepository> >(0)));
}
protected override async Task Context()
{
await base.Context();
_snapshot = await sut.MapToSnapshot(_individualSimulation, _project);
var individualSimulation = new IndividualSimulation
{
Properties = _simulationProperties,
SimulationSettings = _settings,
Model = _model
};
individualSimulation.AddUsedBuildingBlock(new UsedBuildingBlock("IndTemplateId", PKSimBuildingBlockType.Individual)
{
Name = _individual.Name,
BuildingBlock = _individual
});
_modelProperties = new ModelProperties();
A.CallTo(() => _modelPropertiesTask.DefaultFor(_individual.OriginData, _snapshot.Model)).Returns(_modelProperties);
A.CallTo(() => _simulationFactory.CreateFrom(_individual, A <IReadOnlyList <Compound> > ._, _modelProperties, null)).Returns(individualSimulation);
_outputSelection = new OSPSuite.Core.Domain.OutputSelections();
_outputSelection.AddOutput(new QuantitySelection("PATH", QuantityType.BaseGrid));
A.CallTo(() => _outputSelectionMapper.MapToModel(_snapshot.OutputSelections, individualSimulation)).Returns(_outputSelection);
_solver = new SolverSettings();
A.CallTo(() => _solverSettingsMapper.MapToModel(_snapshot.Solver)).Returns(_solver);
_outputSchema = new OutputSchema();
A.CallTo(() => _outputSchemaMapper.MapToModel(_snapshot.OutputSchema)).Returns(_outputSchema);
A.CallTo(() => _curveChartMapper.MapToModel(_snapshotSimulationTimeProfile, A <SimulationAnalysisContext> ._))
.Invokes(x => _context = x.GetArgument <SimulationAnalysisContext>(1))
.Returns(_simulationTimeProfile);
//ensure that run will be performed
_snapshot.HasResults = true;
_calculatedDataRepository = DomainHelperForSpecs.ObservedData("Calculated");
A.CallTo(() => _simulationRunner.RunSimulation(individualSimulation, A <SimulationRunOptions> ._))
.Invokes(x => { individualSimulation.DataRepository = _calculatedDataRepository; });
A.CallTo(() => _eventMappingMapper.MapToModel(_eventSelection, _project)).Returns(_eventMapping);
A.CallTo(() => _observerSetMappingMapper.MapToModel(_observerSetSelection, _project)).Returns(_observerSetMapping);
}
private void addSimulationToChart(IndividualSimulation simulation)
{
_lazyLoadTask.Load(simulation);
if (!simulation.HasResults)
{
throw new PKSimException(PKSimConstants.Error.SimulationHasNoResultsAndCannotBeUsedInSummaryChart(simulation.Name));
}
Chart.AddSimulation(simulation);
UpdateAnalysisBasedOn(simulation, simulation.DataRepository);
_chartTemplatingTask.UpdateDefaultSettings(ChartEditorPresenter, simulation.DataRepository.ToList(), new[] { simulation }, addCurveIfNoSourceDefined: false);
InitializeFromTemplateIfRequired();
showChartView();
}
protected override void Context()
{
base.Context();
_originalSimulation = new IndividualSimulation {
Properties = new SimulationProperties()
};
_clonedSimulation = A.Fake <IndividualSimulation>();
A.CallTo(() => _cloner.Clone(_originalSimulation)).Returns(_clonedSimulation);
_pkSimulation = A.Fake <IndividualSimulation>().WithId("Clone");
var interactionContainer = new Container();
_parameter = DomainHelperForSpecs.ConstantParameterWithValue(10).WithName(CoreConstants.Parameters.KI);
interactionContainer.Add(_parameter);
A.CallTo(() => _interactionTask.AllInteractionContainers(_pkSimulation)).Returns(new[] { interactionContainer });
A.CallTo(() => _objectBaseFactory.Create <IndividualSimulation>()).Returns(_pkSimulation);
}
public void UpdateColumnInternalUse(IndividualSimulation simulation, DataRepository dataRepository = null)
{
var dataRepositoryToUse = dataRepository ?? simulation.DataRepository;
if (dataRepositoryToUse == null)
{
return;
}
var outputSelections = simulation.OutputSelections;
foreach (var column in dataRepositoryToUse.AllButBaseGrid())
{
column.IsInternal = !columnIsSelected(column, outputSelections);
}
}
