private IndividualValuesCache withUpdatedGenderAndRace(IndividualValuesCache individualValuesCache)
{
var parameterValues = individualValuesCache.ParameterValuesCache;
var covariateValuesCache = new CovariateValuesCache();
individualValuesCache.CovariateValuesCache.AllCovariateValues.Each(x =>
{
if (!x.CovariateName.IsOneOf(Constants.Population.RACE_INDEX, Constants.Population.GENDER))
{
covariateValuesCache.Add(x);
}
else if (string.Equals(x.CovariateName, Constants.Population.RACE_INDEX))
{
covariateValuesCache.Add(populationCovariateFrom(x));
}
else
{
covariateValuesCache.Add(genderCovariateFrom(x));
}
});
return(new IndividualValuesCache(parameterValues, covariateValuesCache, individualValuesCache.IndividualIds));
}
private async Task <SimulationResults> runAsync(
IModelCoreSimulation simulation,
IndividualValuesCache population,
AgingData agingData = null,
SimulationRunOptions simulationRunOptions = null)
{
var options = simulationRunOptions ?? new SimulationRunOptions();
initializeProgress(options);
_simulationPersistableUpdater.UpdateSimulationPersistable(simulation);
try
{
var populationRunResults = await _populationRunner.RunPopulationAsync(
simulation,
options,
populationData : _populationTask.PopulationTableFrom(population, simulation),
agingData : agingData?.ToDataTable()
);
return(populationRunResults.Results);
}
finally
{
simulationTerminated();
}
}
private void addCovariates(IndividualValuesCache individualPropertiesCache, Cache <string, List <string> > covariateCache)
{
foreach (var covariate in covariateCache.KeyValues)
{
individualPropertiesCache.AddCovariate(covariate.Key, covariate.Value);
}
}
private IndividualValuesCache withPathsContainingUnitsUpdated(IndividualValuesCache individualValuesCache, PathCache <IParameter> allParameters, IImportLogger logger)
{
// No parameters to check from, return as IS
if (allParameters == null)
{
return(individualValuesCache);
}
//Use TO LIST here because collection might be modified
foreach (var parameterValue in individualValuesCache.AllParameterValues.ToList())
{
var parameterPath = parameterValue.ParameterPath;
if (allParameters.Contains(parameterPath))
{
continue;
}
var pathWithUnitsRemoved = parameterPath.StripUnit();
if (allParameters.Contains(pathWithUnitsRemoved))
{
individualValuesCache.RenamePath(parameterPath, pathWithUnitsRemoved);
parameterValue.ParameterPath = pathWithUnitsRemoved;
continue;
}
logger.AddWarning(Warning.ParameterWithPathNotFoundInBaseIndividual(parameterPath));
individualValuesCache.Remove(parameterPath);
}
return(individualValuesCache);
}
protected override void Context()
{
base.Context();
_individualPropertiesCache = A.Fake <IndividualValuesCache>();
_patchCache = new PathCacheForSpecs <IParameter>();
var individualParameter = A.Fake <IParameter>();
A.CallTo(() => individualParameter.IsChangedByCreateIndividual).Returns(true);
_patchCache.Add("Path1", individualParameter);
var advancedParameter = A.Fake <IParameter>();
A.CallTo(() => advancedParameter.IsChangedByCreateIndividual).Returns(false);
advancedParameter.CanBeVariedInPopulation = true;
_patchCache.Add("PathAdvanced", advancedParameter);
A.CallTo(() => _individualPropertiesCache.AllParameterPaths()).Returns(new[] { "Path1", "Path2", "PathAdvanced" });
A.CallTo(() => _individualPropertiesCache.ParameterValuesFor("Path1")).Returns(_value1);
A.CallTo(() => _individualPropertiesCache.ParameterValuesFor("Path2")).Returns(_value2);
A.CallTo(() => _individualPropertiesCache.ParameterValuesFor("PathAdvanced")).Returns(_value3);
_populationSimulation = A.Fake <PopulationSimulation>();
_parameterValueCache = A.Fake <ParameterValuesCache>();
A.CallTo(() => _populationSimulation.ParameterValuesCache).Returns(_parameterValueCache);
_mobiPopulation = A.Fake <MoBiPopulation>();
A.CallTo(_simulationFactory).WithReturnType <PopulationSimulation>().Returns(_populationSimulation);
A.CallTo(() => _objectBaseFactory.Create <MoBiPopulation>()).Returns(_mobiPopulation);
A.CallTo(() => _parameterRetriever.ParametersFrom(_populationSimulation)).Returns(_patchCache);
A.CallTo(() => _individualPropertiesCacheImporter.ImportFrom(_populationFile, _patchCache, A <IImportLogger> ._)).Returns(_individualPropertiesCache);
_advancedParameterContainer = new AdvancedParameter();
A.CallTo(() => _advancedParameterFactory.Create(advancedParameter, DistributionTypes.Unknown)).Returns(_advancedParameterContainer);
}
protected override Task Context()
{
_containerTask = A.Fake <IContainerTask>();
_progressManager = A.Fake <IProgressManager>();
_individualCacheImporter = A.Fake <IIndividualPropertiesCacheImporter>();
_cloner = A.Fake <ICloner>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_advancedParameterFactory = A.Fake <IAdvancedParameterFactory>();
_createdPopulation = A.Fake <ImportPopulation>();
_individual = new Individual();
_cloneIndividual = new Individual();
A.CallTo(() => _cloner.Clone(_individual)).Returns(_cloneIndividual);
A.CallTo(() => _objectBaseFactory.Create <ImportPopulation>()).Returns(_createdPopulation);
A.CallTo(() => _createdPopulation.IndividualValuesCache).Returns(A.Fake <IndividualValuesCache>());
sut = new ImportPopulationFactory(_objectBaseFactory, _progressManager, _individualCacheImporter, _cloner, _containerTask, _advancedParameterFactory);
A.CallTo(() => _containerTask.CacheAllChildren <IParameter>(_cloneIndividual)).Returns(_allParameters);
A.CallTo(() => _containerTask.CacheAllChildrenSatisfying(_cloneIndividual, A <Func <IParameter, bool> > ._)).Returns(_allCreateIndividualParameters);
_popFile1 = A.Fake <IndividualValuesCache>();
_popFile2 = A.Fake <IndividualValuesCache>();
A.CallTo(() => _individualCacheImporter.ImportFrom(_file1, _allParameters, A <IImportLogger> ._)).Returns(_popFile1);
A.CallTo(() => _individualCacheImporter.ImportFrom(_file2, _allParameters, A <IImportLogger> ._)).Returns(_popFile2);
return(_completed);
}
public override void GlobalContext()
{
base.GlobalContext();
var tmpFile = FileHelper.GenerateTemporaryFileName();
_outputFolder = new FileInfo(tmpFile).DirectoryName;
_individualValuesCache = sut.ImportPopulation(_populationFile);
}
private void addCovariates(IndividualValuesCache population, DataTable dataTable)
{
//and one column for each individual in the population
foreach (var covariateName in population.AllCovariatesNames())
{
addColumnValues(dataTable, covariateName, population.AllCovariateValuesFor(covariateName));
}
}
public void Deconstruct(out IModelCoreSimulation simulation, out IndividualValuesCache population, out AgingData agingData,
out SimulationRunOptions simulationRunOptions)
{
simulation = Simulation;
simulationRunOptions = SimulationRunOptions;
population = Population;
agingData = AgingData;
}
protected override void Context()
{
base.Context();
_simulation = new ModelCoreSimulation();
_population = new IndividualValuesCache();
_populationData = new DataTable();
_simulationRunOptions = new SimulationRunOptions();
A.CallTo(() => _populationTask.PopulationTableFrom(_population, _simulation)).Returns(_populationData);
}
protected override void Context()
{
base.Context();
var tmpFile = FileHelper.GenerateTemporaryFileName();
_outputFolder = new FileInfo(tmpFile).DirectoryName;
//Take the 3 out of 5 which would have indices 6 and 7
_subPopulationFile = _populationTask.SplitPopulation(_populationFile, 5, _outputFolder, "TestSplit")[3];
_subPopulation = _populationTask.ImportPopulation(_subPopulationFile);
}
public override void GlobalContext()
{
base.GlobalContext();
var populationFile = HelperForSpecs.DataFile("pop_5_sparse_id.csv");
var populationTask = Api.GetPopulationTask();
_population = populationTask.ImportPopulation(populationFile);
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation, Population = _population
});
}
private void convertIndividualValueCache(IndividualValuesCache individualValuesCache)
{
var firstParameterValue = individualValuesCache.AllParameterValues.FirstOrDefault();
if (firstParameterValue == null)
{
return;
}
individualValuesCache.IndividualIds.AddRange(Enumerable.Range(0, firstParameterValue.Count));
_converted = true;
}
public void TestSerializationFormulaWithoutObjectPaths()
{
var x1 = new IndividualValuesCache();
x1.SetValues("Path1", new [] { 10, 20, 30d });
x1.SetValues("Path2", new [] { 10, 20, 30d });
x1.AddCovariate("Gender", new [] { "Male", "Female", "Female" });
x1.IndividualIds.AddRange(new [] { 1, 4, 5 });
var x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualIndividualValueCache(x2, x1);
}
public override void GlobalContext()
{
base.GlobalContext();
var populationFile = HelperForSpecs.DataFile("pop_5.csv");
var populationTask = Api.GetPopulationTask();
_population = populationTask.ImportPopulation(populationFile);
//negative volumes ensures that we have one simulation crashing
_population.SetValues("Organism|Liver|Volume", new[] { 2.3, 2.3, 2.3, 2.3, -10 });
_result = _simulationRunner.Run(new SimulationRunArgs {
Simulation = _simulation, Population = _population
});
}
private void validate(IndividualValuesCache individualValues, IImportLogger logger)
{
foreach (var parameterPath in individualValues.AllParameterPaths().ToList())
{
if (allParametersContains(parameterPath))
{
continue;
}
logger.AddWarning(PKSimConstants.Warning.ParameterWithPathNotFoundInBaseIndividual(parameterPath));
individualValues.Remove(parameterPath);
}
}
protected override void Context()
{
base.Context();
_originalValueCache = new ParameterValuesCache();
//3 individuals to in original pop
_originalIndividualIds = new List <int> {
1, 2, 3
};
var parameterValues1 = new ParameterValues("Path1");
parameterValues1.Add(new double[] { 2, 3, 4 });
var parameterValues2 = new ParameterValues("Path2");
parameterValues2.Add(new double[] { 4, 5, 6 });
_originalValueCache.Add(parameterValues1);
_originalValueCache.Add(parameterValues2);
_originalCovariates = new CovariateValuesCache();
_originalCovariates.Add("Gender", new[] { "Male", "Female", "Female" });
_parameterCache = new PathCacheForSpecs <IParameter>();
_cacheToMerge = new ParameterValuesCache();
var parameterValuesToMerge1 = new ParameterValues("Path1");
parameterValuesToMerge1.Add(new double[] { 10, 20 });
_cacheToMerge.Add(parameterValuesToMerge1);
var parameterValuesToMerge2 = new ParameterValues("Path3");
parameterValuesToMerge2.Add(new double[] { 30, 40 });
_cacheToMerge.Add(parameterValuesToMerge2);
_covariatesToMerge = new CovariateValuesCache();
_covariatesToMerge.Add("Gender", new[] { "Female", "Female" });
_covariatesToMerge.Add("Population", new[] { "European", "American" });
_individualIdsToMerge = new List <int> {
10, 20
};
sut = new IndividualValuesCache(_originalValueCache, _originalCovariates, _originalIndividualIds);
_individualPropertiesCacheToMerge = new IndividualValuesCache(_cacheToMerge, _covariatesToMerge, _individualIdsToMerge);
}
protected override void Context()
{
base.Context();
_simulation = new ModelCoreSimulation();
_population = new IndividualValuesCache();
_populationData = new DataTable();
_simulationRunOptions = new SimulationRunOptions();
_agingData = new AgingData
{
IndividualIds = new[] { 0, 1 },
ParameterPaths = new[] { "Organism|Liver|Volume", "Organism|Liver|Volume" },
Times = new[] { 10, 20.0 },
Values = new[] { 4.0, 5.0 },
};
A.CallTo(() => _populationTask.PopulationTableFrom(_population, _simulation)).Returns(_populationData);
}
public DataTable PopulationTableFrom(IndividualValuesCache population, IModelCoreSimulation simulation = null)
{
var dataTable = new DataTable();
var allParameters = _entitiesInSimulationRetriever.QuantitiesFrom(simulation);
dataTable.BeginLoadData();
//add individual ids column
population.IndividualIds.Each(i => dataTable.Rows.Add(dataTable.NewRow()));
addColumnValues(dataTable, Constants.Population.INDIVIDUAL_ID_COLUMN, population.IndividualIds);
//Create one column for the parameter path
addCovariates(population, dataTable);
//add advanced parameters
foreach (var parameterValues in population.AllParameterValues)
{
var parameterPathWithoutUnit = allParameters.Contains(parameterValues.ParameterPath) ? parameterValues.ParameterPath : parameterValues.ParameterPath.StripUnit();
addColumnValues(dataTable, parameterPathWithoutUnit, parameterValues.Values);
}
dataTable.EndLoadData();
return dataTable;
}
protected override void Because()
{
_results = sut.ImportFrom(DomainHelperForSpecs.PopulationFilePathFor("corrupt1"), _allParameters, _logger);
}
protected override void Because()
{
_results = sut.ImportFrom(_fileName, _allParameters, _logger);
}
protected override void Because()
{
_results = sut.ImportFrom(DomainHelperForSpecs.PopulationFilePathFor("new_format_with_comment"), _allParameters, _logger);
}
public override void GlobalContext()
{
base.GlobalContext();
_individualValuesCache = sut.ImportPopulation(_populationFile);
}
private void mergeImportedIndividualsInPopulation(ImportPopulation importPopulation, IndividualValuesCache individualValues)
{
importPopulation.IndividualValuesCache.Merge(individualValues, _allParameters);
}
public CreatePopulationResults(IndividualValuesCache individualValuesCache, int seed)
{
IndividualValuesCache = individualValuesCache;
Seed = seed;
}
protected override void Because()
{
_result = sut.CreatePopulation(_populationCharacteristics);
}
public override void GlobalContext()
{
base.GlobalContext();
_simulation = _simulationPersister.LoadSimulation(_simulationFile);
_individualValuesCache = sut.ImportPopulation(_populationFileWithUnitInParameterName);
}
protected override void Context()
{
base.Context();
_population = _populationTask.ImportPopulation(_populationFile);
}
private IndividualValuesCache createIndividualPropertiesFromCSV(CsvReader csv, string[] headers)
{
var individualPropertiesCache = new IndividualValuesCache();
//first create a cache of all possible values
var covariateCache = new Cache <string, List <string> >();
var parameterValues = new Cache <string, List <double> >();
int fieldCount = csv.FieldCount;
int indexIndividualId = 0;
for (int i = 0; i < headers.Length; i++)
{
var header = headers[i].StripUnit();
if (string.Equals(header, Constants.Population.INDIVIDUAL_ID_COLUMN))
{
indexIndividualId = i;
continue;
}
if (entryRepresentsParameter(header))
{
parameterValues[header] = new List <double>();
}
else
{
covariateCache[header] = new List <string>();
}
}
while (csv.ReadNextRecord())
{
for (int i = 0; i < fieldCount; i++)
{
var header = headers[i].StripUnit();
if (i == indexIndividualId)
{
individualPropertiesCache.IndividualIds.Add(csv.IntAt(i));
}
else if (parameterValues.Contains(header))
{
parameterValues[header].Add(csv.DoubleAt(i));
}
else
{
covariateCache[header].Add(csv[i]);
}
}
}
//now fill the property cache
addCovariates(individualPropertiesCache, covariateCache);
foreach (var parameterValue in parameterValues.KeyValues)
{
individualPropertiesCache.SetValues(parameterValue.Key, parameterValue.Value);
}
return(individualPropertiesCache);
}
protected Population() : base(PKSimBuildingBlockType.Population)
{
IndividualValuesCache = new IndividualValuesCache();
SelectedDistributions = new ParameterDistributionSettingsCache();
Seed = Environment.TickCount;
}
