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; }