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.IndividualPropertiesCache).Returns(A.Fake <IndividualPropertiesCache>());
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 <IndividualPropertiesCache>();
_popFile2 = A.Fake <IndividualPropertiesCache>();
A.CallTo(() => _individualCacheImporter.ImportFrom(_file1, _allParameters, A <IImportLogger> ._)).Returns(_popFile1);
A.CallTo(() => _individualCacheImporter.ImportFrom(_file2, _allParameters, A <IImportLogger> ._)).Returns(_popFile2);
return(_completed);
}
public Individual CreateBaseIndividualForPopulation(Individual originalIndividual)
{
//we need to create a new individual WITHOUT CKD and set all percentiles as in the original individuals. Other parameters, value wil be taken as is
var originData = originalIndividual.OriginData.Clone();
//remove the disease state to create a healthy Individual
originData.DiseaseState = null;
var healthyIndividual = _individualFactory.CreateAndOptimizeFor(originData, originalIndividual.Seed);
var allCKDParameters = parametersChangedByCKDAlgorithmAsList(healthyIndividual);
//Make sure we update the flags that might not be set coming from the database
allCKDParameters.Each(x => x.IsChangedByCreateIndividual = true);
//do not update parameters changed by CKD algorithm or that are not visible
var allHealthyParameters = _containerTask.CacheAllChildrenSatisfying <IParameter>(healthyIndividual, x => !allCKDParameters.Contains(x) && x.Visible);
var allOriginalParameters = _containerTask.CacheAllChildren <IParameter>(originalIndividual);
_parameterSetUpdater.UpdateValues(allOriginalParameters, allHealthyParameters);
//we have a healthy individuals based on the CKD individual where all changes were all manual changes were accounted for
//we now need to add the disease state contributions from the original individual
originData.DiseaseState = originalIndividual.OriginData.DiseaseState;
originalIndividual.OriginData.DiseaseStateParameters.Each(x => originData.AddDiseaseStateParameter(x.Clone()));
return(healthyIndividual);
}
private void randomizeDistributedParameterIn(Individual individual)
{
//all distribued parameters in individual that are not standard parameters
var allDistributedParameer = _containerTask.CacheAllChildrenSatisfying <IDistributedParameter>(
individual, p => !CoreConstants.Parameter.StandardCreateIndividualParameters.Contains(p.Name));
foreach (var parameter in allDistributedParameer)
{
parameter.Value = parameter.RandomDeviateIn(_randomGenerator);
}
}
public IEnumerable <ParameterScaling> AllParameterScalingsFrom(Individual originIndividual, Individual targetIndividual)
{
//only show parameter for scaling that are visble parameters
var allTargetParameters = _containerTask.CacheAllChildren <IParameter>(targetIndividual);
//default individul based on origin indivudal (used to retrieve default value)
var allOriginParameters = _containerTask.CacheAllChildrenSatisfying <IParameter>(originIndividual, scalingAllowedFor);
//return parameter scaling for all parameters existing in the source and target compartment
return(from originParameter in allOriginParameters.KeyValues
let targetParameter = allTargetParameters[originParameter.Key]
where scalingRequiredFor(originParameter.Value, targetParameter)
select parameterScalingFor(originParameter.Value, targetParameter));
}
public async Task <ImportPopulation> CreateFor(IReadOnlyCollection <string> files, Individual individual, CancellationToken cancellationToken)
{
try
{
using (var progressUpdater = _progressManager.Create())
{
var importPopulation = createPopulationFor(individual);
var popIndiviudal = importPopulation.Settings.BaseIndividual;
_allParameters = _containerTask.CacheAllChildren <IParameter>(popIndiviudal);
_allCreateIndividualParameters = _containerTask.CacheAllChildrenSatisfying <IParameter>(popIndiviudal, x => x.IsChangedByCreateIndividual);
var settings = importPopulation.Settings;
progressUpdater.Initialize(files.Count, PKSimConstants.UI.CreatingPopulation);
//Create the new task and start the import using to list
var tasks = files.Select(f => importFiles(f, cancellationToken)).ToList();
// Add a loop to process the tasks one at a time until none remain.
while (tasks.Count > 0)
{
cancellationToken.ThrowIfCancellationRequested();
// Identify the first task that completes.
var firstFinishedTask = await Task.WhenAny(tasks);
// Remove the selected task from the list so that you don't
// process it more than once.
tasks.Remove(firstFinishedTask);
// Await the completed task.
var importResult = await firstFinishedTask;
settings.AddFile(importResult.PopulationFile);
mergeImportedIndividualsInPopulation(importPopulation, importResult.IndividualValues);
progressUpdater.IncrementProgress();
}
//once all individuals have been imported, we need to create advanced parameters
createAdvancedParametersFor(importPopulation);
return(importPopulation);
}
}
finally
{
_allCreateIndividualParameters.Clear();
_allParameters.Clear();
}
}
private void updateIsChangedByCreatedIndividualFlag(Individual individual)
{
var defaultHuman = _defaultIndividualRetriever.DefaultHuman();
var allIsChangedByIndividualParameter = _containerTask.CacheAllChildrenSatisfying <IParameter>(defaultHuman, x => x.IsChangedByCreateIndividual);
var allParameters = _containerTask.CacheAllChildren <IParameter>(individual);
allIsChangedByIndividualParameter.KeyValues.Each(kv =>
{
var parameter = allParameters[kv.Key];
//can be null for a new parameter added at some point in the future
if (parameter != null)
{
parameter.IsChangedByCreateIndividual = true;
}
});
}
private IReadOnlyList <string> parameterPathsToVaryFrom(SensitivityAnalysis sensitivityAnalysis)
{
var simulation = sensitivityAnalysis.Simulation;
var constantParametersCache = _containerTask.CacheAllChildrenSatisfying <IParameter>(simulation.Model.Root, ParameterCanBeUsedForSensitivity);
var allUsedParameterPaths = sensitivityAnalysis.ParameterPaths.Any()
? sensitivityAnalysis.ParameterPaths
: _simulationAnalyzer.AllPathOfParametersUsedInSimulation(sensitivityAnalysis.Simulation);
return(allUsedParameterPaths.Select(x => new
{
Parameter = constantParametersCache[x],
Path = x
})
.Where(x => x.Parameter != null)
.Select(x => x.Path).ToList());
}
private void convertCompound(Compound compound)
{
if (compound == null)
{
return;
}
var templateCompound = _compoundFactory.Create().WithName(compound.Name);
var solubilityTable = templateCompound.Parameter(CoreConstants.Parameters.SOLUBILITY_TABLE);
compound.Add(_cloner.Clone(solubilityTable));
var solubilityGroup = compound.ParameterAlternativeGroup(CoreConstants.Groups.COMPOUND_SOLUBILITY);
solubilityGroup.AllAlternatives.Each(x => x.Add(_cloner.Clone(solubilityTable)));
var templateParameterCache = _containerTask.CacheAllChildrenSatisfying <IParameter>(templateCompound, x => !x.IsDefault);
var compoundParameterCache = _containerTask.CacheAllChildren <IParameter>(compound);
foreach (var parameterPath in templateParameterCache.Keys)
{
setAsInput(compoundParameterCache[parameterPath]);
}
foreach (var templateAlternativeGroup in templateCompound.AllParameterAlternativeGroups())
{
var templateAlternative = templateAlternativeGroup.AllAlternatives.First();
var compoundGroup = compound.ParameterAlternativeGroup(templateAlternativeGroup.Name);
foreach (var alternative in compoundGroup.AllAlternatives)
{
updateIsInputStateByNameAndValue(alternative, templateAlternative);
}
}
foreach (var process in compound.AllProcesses())
{
var templateProcess = _compoundProcessRepository.ProcessByName(process.InternalName);
updateIsInputStateByNameAndValue(process, templateProcess);
}
_converted = true;
}
private IEnumerable <object> anatomyAndPhysiologyFor(Individual individual)
{
var report = new List <object>();
var allParameters = _containerTask.CacheAllChildrenSatisfying <IParameter>(individual, valueShouldBeExportedForAnatomy);
if (!allParameters.Any())
{
report.Add(PKSimConstants.UI.Default);
return(report);
}
var dataTable = new DataTable {
TableName = PKSimConstants.UI.AnatomyAndPhysiology
};
dataTable.AddColumn(PKSimConstants.UI.Parameter);
dataTable.AddColumn(PKSimConstants.UI.Value);
dataTable.AddColumn(PKSimConstants.UI.DefaultValue);
foreach (var parameter in allParameters)
{
var row = dataTable.NewRow();
row[PKSimConstants.UI.Parameter] = _fullPathDisplayResolver.FullPathFor(parameter);
row[PKSimConstants.UI.Value] = ParameterMessages.DisplayValueFor(parameter);
row[PKSimConstants.UI.DefaultValue] = ParameterMessages.DisplayValueFor(parameter, parameter.DefaultValue.GetValueOrDefault(parameter.Value));
dataTable.Rows.Add(row);
}
var table = new Table(dataTable.DefaultView, new Text(dataTable.TableName));
var reference = new Reference(table);
var text = new Text(PKSimConstants.UI.AnatomyAndPhysiologyText, reference);
report.Add(text);
report.Add(table);
return(report);
}
private PathCache <IParameter> getAllCreateIndividualParametersFrom(Individual individual)
{
return(_containerTask.CacheAllChildrenSatisfying <IParameter>(individual, p => p.IsChangedByCreateIndividual));
}
public IndividualProperties MapFrom(Individual individual)
{
var pathCache = _containerTask.CacheAllChildrenSatisfying <IParameter>(individual, p => p.IsChangedByCreateIndividual);
return(MapFrom(individual, pathCache));
}
private PathCache <IQuantity> allQuantitiesFrom(IMoBiSimulation simulation, bool includeAmounts)
{
return(_containerTask.CacheAllChildrenSatisfying <IQuantity>(simulation.Model.Root, x => QuantityIsSelectable(x, includeAmounts)));
}
public PathCache <TEntity> EntitiesFrom <TEntity>(IContainer container, Func <TEntity, bool> predicate) where TEntity : class, IEntity
{
return(_containerTask.CacheAllChildrenSatisfying(container, predicate));
}