public DataTable PKAnalysesToDataTable(PopulationSimulationPKAnalyses pkAnalyses, IModelCoreSimulation simulation)
{
var dataTable = new DataTable(simulation.Name);
dataTable.AddColumn <int>(INDIVIDUAL_ID);
dataTable.AddColumn <string>(QUANTITY_PATH);
dataTable.AddColumn <string>(PARAMETER);
dataTable.AddColumn <string>(VALUE);
dataTable.AddColumn <string>(UNIT);
dataTable.BeginLoadData();
foreach (var quantityPKParameter in pkAnalyses.All())
{
var quantityPath = quantityPKParameter.QuantityPath;
var molWeight = simulation.MolWeightFor(quantityPath);
var pkParameter = _pkParameterRepository.FindByName(quantityPKParameter.Name);
var quantityPKParameterContext = new QuantityPKParameterContext(quantityPKParameter, molWeight);
var mergedDimension = _dimensionFactory.MergedDimensionFor(quantityPKParameterContext);
var unit = mergedDimension.UnitOrDefault(pkParameter.DisplayUnit);
quantityPKParameter.ValueCache.KeyValues.Each(kv =>
{
var row = dataTable.NewRow();
row[INDIVIDUAL_ID] = kv.Key;
row[QUANTITY_PATH] = inQuote(quantityPath);
row[PARAMETER] = inQuote(pkParameter.Name);
row[VALUE] = mergedDimension.BaseUnitValueToUnitValue(unit, kv.Value).ConvertedTo <string>();
row[UNIT] = unit.Name;
dataTable.Rows.Add(row);
});
}
dataTable.EndLoadData();
return(dataTable);
}
protected override void Context()
{
base.Context();
var pKAnalyses = new PopulationSimulationPKAnalyses();
_populationSimulation = new PopulationSimulation {
PKAnalyses = pKAnalyses
};
var pkParameter = new QuantityPKParameter {
QuantityPath = "Liver", Name = "P"
};
var dimension = A.Fake <IDimension>();
var unit = A.Fake <Unit>();
A.CallTo(() => unit.Name).Returns("UNIT");
A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(pkParameter, null)).Returns(unit);
pkParameter.Dimension = dimension;
pkParameter.SetNumberOfIndividuals(2);
pkParameter.SetValue(0, 10);
pkParameter.SetValue(1, 11);
A.CallTo(() => dimension.BaseUnitValueToUnitValue(unit, 10)).Returns(100.10);
A.CallTo(() => dimension.BaseUnitValueToUnitValue(unit, 11)).Returns(110.20);
pKAnalyses.AddPKAnalysis(pkParameter);
}
protected override void Because()
{
_pkAnalysis = sut.CalculateFor(new CalculatePKAnalysisArgs {
Simulation = _simulation, SimulationResults = _result
});
_table = sut.ConvertToDataTable(_pkAnalysis, _simulation);
}
private void addPKParametersForOutput(ISimulation simulation, int numberOfIndividuals, SimulationResults runResults, Action <int> performIndividualScalingAction,
QuantitySelection selectedQuantity, PopulationSimulationPKAnalyses popAnalyses, string moleculeName,
PKCalculationOptions pkCalculationOptions, IReadOnlyList <PKCalculationOptionsFactory.ApplicationParameters> allApplicationParameters)
{
var availablePKParameters = _pkParameterRepository.All().Where(p => PKParameterCanBeUsed(p, pkCalculationOptions)).ToList();
//create pk parameter for each quantities
foreach (var pkParameter in availablePKParameters)
{
var quantityPKParameter = new QuantityPKParameter {
Name = pkParameter.Name, QuantityPath = selectedQuantity.Path, Dimension = pkParameter.Dimension
};
quantityPKParameter.SetNumberOfIndividuals(numberOfIndividuals);
popAnalyses.AddPKAnalysis(quantityPKParameter);
}
//add the values for each individual
foreach (var individualResult in runResults.AllIndividualResults)
{
performIndividualScalingAction(individualResult.IndividualId);
_pkCalculationOptionsFactory.UpdateAppliedDose(simulation, moleculeName, pkCalculationOptions, allApplicationParameters);
var values = individualResult.ValuesFor(selectedQuantity.Path);
var pkValues = _pkValuesCalculator.CalculatePK(individualResult.Time.Values, values.Values, pkCalculationOptions);
foreach (var pkParameter in availablePKParameters)
{
var quantityPKParameter = popAnalyses.PKParameterFor(selectedQuantity.Path, pkParameter.Name);
quantityPKParameter.SetValue(individualResult.IndividualId, pkValues.ValueOrDefaultFor(pkParameter.Name));
}
}
}
private SimulationAnalysesMetaData mapFrom(PopulationSimulationPKAnalyses populationPKAnalyses)
{
return(new SimulationAnalysesMetaData
{
Content = { Data = _serializationManager.Serialize(populationPKAnalyses) }
});
}
protected override void Context()
{
base.Context();
_pkAnalysis = new PopulationSimulationPKAnalyses();
_populationSimulation = A.Fake <IModelCoreSimulation>();
var quantityPKParameter = new QuantityPKParameter {
QuantityPath = "Liver", Name = "P"
};
var pkParameter = new PKParameter {
DisplayUnit = "UNIT", Name = "P"
};
A.CallTo(() => _pkParameterRepository.FindByName(quantityPKParameter.Name)).Returns(pkParameter);
var mergedDimension = A.Fake <IDimension>();
quantityPKParameter.SetValue(0, 10);
quantityPKParameter.SetValue(1, 11);
A.CallTo(() => _dimensionFactory.MergedDimensionFor(A <QuantityPKParameterContext> ._))
.WhenArgumentsMatch(x => x.Get <QuantityPKParameterContext>(0).QuantityPKParameter == quantityPKParameter)
.Returns(mergedDimension);
var unit = A.Fake <Unit>();
A.CallTo(() => unit.Name).Returns(pkParameter.DisplayUnit);
A.CallTo(() => mergedDimension.UnitOrDefault(pkParameter.DisplayUnit)).Returns(unit);
A.CallTo(() => mergedDimension.BaseUnitValueToUnitValue(unit, 10)).Returns(100.10f);
A.CallTo(() => mergedDimension.BaseUnitValueToUnitValue(unit, 11)).Returns(110.20f);
_pkAnalysis.AddPKAnalysis(quantityPKParameter);
}
protected override void Context()
{
base.Context();
_populationSimulation = A.Fake <PopulationSimulation>().WithId("Toto");
_anaylysesMetaData = A.Fake <SimulationAnalysesMetaData>();
_simPkAnalyses = new PopulationSimulationPKAnalyses();
A.CallTo(() => _simulationAnalysesQuery.ResultFor(_populationSimulation.Id)).Returns(_anaylysesMetaData);
A.CallTo(_serializationManager).WithReturnType <PopulationSimulationPKAnalyses>().Returns(_simPkAnalyses);
}
public void should_return_the_expected_path_values()
{
var sut = new PopulationSimulationPKAnalyses();
sut.AddPKAnalysis(createPKAnalyses("Path1"));
sut.AddPKAnalysis(createPKAnalyses("Path2"));
sut.AllQuantityPaths.ShouldOnlyContain("Path1", "Path2");
}
public PopulationSimulationPKAnalyses ImportPKAnalysesFromCSV(string fileName, IModelCoreSimulation simulation)
{
var pkSimulationImport = _simulationPKParametersImportTask.ImportPKParameters(fileName, simulation, CancellationToken.None).Result;
pkSimulationImport.ThrowOnError();
_logger.Log(pkSimulationImport);
var simulationPKAnalyses = new PopulationSimulationPKAnalyses();
pkSimulationImport.PKParameters.Each(x => simulationPKAnalyses.AddPKAnalysis(x));
return(simulationPKAnalyses);
}
public void Visit(PopulationSimulationPKAnalyses populationSimulationPKAnalyses)
{
var allQuantityPKAnalysis = populationSimulationPKAnalyses.All().ToList();
populationSimulationPKAnalyses.Clear();
allQuantityPKAnalysis.Each(x =>
{
x.Name = ConvertPKParameterName(x.Name);
populationSimulationPKAnalyses.AddPKAnalysis(x);
});
_converted = true;
}
protected override void Context()
{
_pkAnalysisTask = A.Fake <ISensitivityAnalysisPKAnalysesTask>();
sut = new SensitivityAnalysisRunResultCalculator(_pkAnalysisTask);
_pkAnalyses = new PopulationSimulationPKAnalyses();
_sensitivityAnalysis = new SensitivityAnalysis();
_variationData = new VariationData();
_simulationResults = new SimulationResults();
A.CallTo(_pkAnalysisTask).WithReturnType <PopulationSimulationPKAnalyses>().Returns(_pkAnalyses);
}
protected override void Context()
{
_token = new CancellationToken();
_populationSimulation = A.Fake <PopulationSimulation>();
_pkAnalyses = A.Fake <PopulationSimulationPKAnalyses>();
_populationSimulation.PKAnalyses = _pkAnalyses;
_quantityRetriever = A.Fake <IEntitiesInContainerRetriever>();
_pkAnalysesImporter = A.Fake <ISimulationPKAnalysesImporter>();
_availableQuantities = new PathCacheForSpecs <IQuantity>();
A.CallTo(_pkAnalysesImporter).WithReturnType <IEnumerable <QuantityPKParameter> >().Returns(_importedPKParameters);
A.CallTo(() => _quantityRetriever.OutputsFrom(_populationSimulation)).Returns(_availableQuantities);
sut = new SimulationPKParametersImportTask(_pkAnalysesImporter, _quantityRetriever);
}
protected override void Context()
{
base.Context();
_context = A.Fake <IExecutionContext>();
_pkParameter1 = A.Fake <QuantityPKParameter>();
A.CallTo(() => _pkParameter1.Id).Returns("Id1");
_pkParameter2 = A.Fake <QuantityPKParameter>();
A.CallTo(() => _pkParameter2.Id).Returns("Id2");
_pkParameters.Add(_pkParameter1);
_pkParameters.Add(_pkParameter2);
_pkAnalysis = new PopulationSimulationPKAnalyses();
_populationSimulation.PKAnalyses = _pkAnalysis;
}
protected override void Context()
{
base.Context();
_quantityPKParameter1 = new QuantityPKParameter {
QuantityPath = "Path1", Name = "AUC"
};
_quantityPKParameter2 = new QuantityPKParameter {
QuantityPath = "Path1", Name = "C_max"
};
_pop_pk = new PopulationSimulationPKAnalyses();
_pop_pk.AddPKAnalysis(_quantityPKParameter1);
_pop_pk.AddPKAnalysis(_quantityPKParameter2);
}
private void warnIfParameterAlreadyExists(PopulationSimulationPKAnalyses pkAnalyses, QuantityPKParameter pkParameter, SimulationPKParametersImport importedPKParameter)
{
if (pkAnalyses.IsNull())
{
return;
}
if (pkAnalyses.PKParameterBy(pkParameter.Id) == null)
{
return;
}
importedPKParameter.AddWarning(PKSimConstants.Warning.PKParameterAlreadyExistsAndWillBeOverwritten(pkParameter.Name, pkParameter.QuantityPath));
}
protected override Task Context()
{
_token = new CancellationToken();
_populationSimulation = A.Fake <PopulationSimulation>();
_pkAnalyses = A.Fake <PopulationSimulationPKAnalyses>();
_populationSimulation.PKAnalyses = _pkAnalyses;
_corePKParameterImporter = A.Fake <OSPSuite.Infrastructure.Import.Services.ISimulationPKParametersImportTask>();
var coreSimulationPKParameterImport = new SimulationPKParametersImport {
PKParameters = _importedPKParameters
};
A.CallTo(_corePKParameterImporter).WithReturnType <Task <SimulationPKParametersImport> >().Returns(coreSimulationPKParameterImport);
sut = new SimulationPKParametersImportTask(_corePKParameterImporter);
return(_completed);
}
public void TestSerializationPopulationSimulationPKAnalyses()
{
var x1 = new PopulationSimulationPKAnalyses();
x1.AddPKAnalysis(createPKAnalyses("Path1"));
x1.AddPKAnalysis(createPKAnalyses("Path2"));
x1.AddPKAnalysis(createPKAnalyses("Path3"));
x1.AddPKAnalysis(createPKAnalyses("Path4"));
x1.AddPKAnalysis(createPKAnalyses("Path5"));
var x2 = SerializeAndDeserialize(x1);
x2.ShouldNotBeNull();
x2.All().Count().ShouldBeEqualTo(5);
x2.PKParameterFor("Path1", "AUC").Count.ShouldBeEqualTo(_numberOfIndividuals);
}
private void addPKParametersForOutput(
IModelCoreSimulation simulation,
SimulationResults simulationResults,
Action <int> performIndividualScalingAction,
QuantitySelection selectedQuantity,
PopulationSimulationPKAnalyses popAnalyses,
string moleculeName,
PKCalculationOptions pkCalculationOptions,
IReadOnlyList <ApplicationParameters> allApplicationParameters)
{
var allPKParameters = _pkParameterRepository.All().Where(p => PKParameterCanBeUsed(p, pkCalculationOptions)).ToList();
var allUserDefinedPKParameters = allPKParameters.OfType <UserDefinedPKParameter>().ToList();
//create pk parameter for each pk parameters (predefined and dynamic)
foreach (var pkParameter in allPKParameters)
{
var quantityPKParameter = new QuantityPKParameter {
Name = pkParameter.Name, QuantityPath = selectedQuantity.Path, Dimension = pkParameter.Dimension
};
popAnalyses.AddPKAnalysis(quantityPKParameter);
}
//add the values for each individual
foreach (var individualResult in simulationResults.AllIndividualResults)
{
performIndividualScalingAction(individualResult.IndividualId);
_pkCalculationOptionsFactory.UpdateTotalDrugMassPerBodyWeight(simulation, moleculeName, pkCalculationOptions, allApplicationParameters);
var values = individualResult.QuantityValuesFor(selectedQuantity.Path);
//This can happen is the results do not match the simulation
if (values == null)
{
continue;
}
var pkValues = _pkValuesCalculator.CalculatePK(individualResult.Time.Values, values.Values, pkCalculationOptions, allUserDefinedPKParameters);
foreach (var quantityPKParameter in popAnalyses.AllPKParametersFor(selectedQuantity.Path))
{
quantityPKParameter.SetValue(individualResult.IndividualId, pkValues.ValueOrDefaultFor(quantityPKParameter.Name));
}
}
}
protected virtual PopulationSimulationPKAnalyses CalculateFor(ISimulation simulation, int numberOfIndividuals, SimulationResults runResults, Action <int> performIndividualScalingAction)
{
_lazyLoadTask.Load(simulation);
var popAnalyses = new PopulationSimulationPKAnalyses();
foreach (var selectedQuantityForMolecule in simulation.OutputSelections.GroupBy(moleculeNameFrom))
{
var moleculeName = selectedQuantityForMolecule.Key;
var pkCalculationOptions = _pkCalculationOptionsFactory.CreateFor(simulation, moleculeName);
var allApplicationParameters = _pkCalculationOptionsFactory.AllApplicationParametersOrderedByStartTimeFor(simulation, moleculeName);
foreach (var selectedQuantity in selectedQuantityForMolecule)
{
addPKParametersForOutput(simulation, numberOfIndividuals, runResults, performIndividualScalingAction, selectedQuantity, popAnalyses, moleculeName, pkCalculationOptions, allApplicationParameters);
}
}
return(popAnalyses);
}
protected override void Context()
{
base.Context();
_context = A.Fake <IExecutionContext>();
_quantityRetriever = A.Fake <IEntitiesInContainerRetriever>();
_populationAnalysisTask = A.Fake <IPKAnalysesTask>();
_pkAnalyses = A.Fake <PopulationSimulationPKAnalyses>();
_quantityCache = new PathCacheForSpecs <IQuantity>();
_quantity1 = new MoleculeAmount();
_quantity2 = new MoleculeAmount();
_quantityCache.Add("PATH1", _quantity1);
_quantityCache.Add("PATH2", _quantity2);
A.CallTo(() => _context.Resolve <IEntitiesInContainerRetriever>()).Returns(_quantityRetriever);
A.CallTo(() => _context.Resolve <IPKAnalysesTask>()).Returns(_populationAnalysisTask);
A.CallTo(() => _quantityRetriever.QuantitiesFrom(_populationSimulation)).Returns(_quantityCache);
A.CallTo(() => _populationAnalysisTask.CalculateFor(_populationSimulation)).Returns(_pkAnalyses);
_allQuantityPaths = new List <string> {
"PATH1", "PATH2"
};
_simulationSettings = new OutputSelections();
A.CallTo(() => _populationSimulation.OutputSelections).Returns(_simulationSettings);
A.CallTo(() => _simulationResults.AllQuantityPaths()).Returns(_allQuantityPaths);
}
public Task <DataTable> PKAnalysesToDataTableAsync(PopulationSimulationPKAnalyses pkAnalyses, IModelCoreSimulation simulation)
{
return(Task.Run(() => PKAnalysesToDataTable(pkAnalyses, simulation)));
}
public static bool IsNull(this PopulationSimulationPKAnalyses populationPKAnalyses)
{
return(populationPKAnalyses == null || populationPKAnalyses.IsAnImplementationOf <NullPopulationSimulationPKAnalyses>());
}
protected override void Because()
{
_popAnalaysis = sut.CalculateFor(_simulation, 1, _runResults);
}
public void ExportPKAnalysesToCSV(PopulationSimulationPKAnalyses pkAnalyses, IModelCoreSimulation simulation, string fileName)
{
var dataTable = ConvertToDataTable(pkAnalyses, simulation);
dataTable.ExportToCSV(fileName);
}
public DataTable ConvertToDataTable(PopulationSimulationPKAnalyses pkAnalyses, IModelCoreSimulation simulation)
{
return(_populationSimulationPKAnalysesToDataTableConverter.PKAnalysesToDataTable(pkAnalyses, simulation));
}
protected override void Because()
{
_results = sut.CalculateFor(_populationSimulation);
}
public void Visit(PopulationSimulationPKAnalyses populationSimulationPKAnalyses)
{
(_, _converted) = _converter730To90.Convert(populationSimulationPKAnalyses);
}
protected override void Because()
{
_pkAnalysis = sut.CalculateFor(new CalculatePKAnalysisArgs {
Simulation = _simulation, SimulationResults = _result
});
}
protected override void Because()
{
_result = sut.ImportPKAnalysesFromCSV(_pkParameterFile, _simulation);
}
