public Individual CreateAndOptimizeFor(OriginData originData, int?seed = null)
{
var individual = CreateStandardFor(originData);
if (seed.HasValue)
{
individual.Seed = seed.Value;
}
//this creates a healthy individual
_createIndividualAlgorithm.Optimize(individual);
//Apply disease states if required
var diseaseStateImplementation = _diseaseStateImplementationFactory.CreateFor(individual);
diseaseStateImplementation.ApplyTo(individual);
validate(individual);
return(individual);
}
private Individual createStandardIndividual(OriginData originData, Func <IIndividualModelTask, Action <Individual> > createAction)
{
var individual = _objectBaseFactory.Create <Individual>();
individual.OriginData = originData;
//default icon for an individual is the name of the species
individual.Icon = originData.Species.Name;
var rootContainer = _objectBaseFactory.Create <IRootContainer>();
rootContainer.Add(_objectBaseFactory.Create <Organism>());
rootContainer.Add(_objectBaseFactory.Create <IContainer>()
.WithName(Constants.NEIGHBORHOODS)
.WithMode(ContainerMode.Logical));
individual.Root = rootContainer;
createAction(_individualModelTask)(individual);
//Update parameters defined in origin data and also in individual
setParameter(individual, CoreConstants.Parameters.AGE, originData.Age, originData.AgeUnit);
setParameter(individual, Constants.Parameters.GESTATIONAL_AGE, originData.GestationalAge, originData.GestationalAgeUnit, individual.IsPreterm);
setParameter(individual, CoreConstants.Parameters.HEIGHT, originData.Height, originData.HeightUnit);
//Do not update value for BMI and weight in individual as this parameter are defined as formula parameter
setParameterDisplayUnit(individual, CoreConstants.Parameters.WEIGHT, originData.WeightUnit, originData.ValueOrigin);
//Do not uddate valuye origin for BMI as this is not an input from the user
setParameterDisplayUnit(individual, CoreConstants.Parameters.BMI, originData.BMIUnit);
//update ontogeny parameters
_ontogenyVariabilityUpdater.UpdatePlasmaProteinsOntogenyFor(individual);
validate(individual);
individual.IsLoaded = true;
return(individual);
}
public virtual OriginData Clone()
{
var clone = new OriginData
{
Age = Age,
AgeUnit = AgeUnit,
Comment = Comment,
Height = Height,
HeightUnit = HeightUnit,
BMI = BMI,
BMIUnit = BMIUnit,
SpeciesPopulation = SpeciesPopulation,
Gender = Gender,
Species = Species,
SubPopulation = SubPopulation,
Weight = Weight,
WeightUnit = WeightUnit,
GestationalAge = GestationalAge,
CalculationMethodCache = CalculationMethodCache.Clone()
};
clone.UpdateValueOriginFrom(ValueOrigin);
return(clone);
}
public void UpdateDistributionBasedOn(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, IDistributedParameter baseParameter, OriginData originData)
{
throw new PKSimException("Should not be called");
}
public void UpdateDistributionBasedOn(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, IDistributedParameter baseParameter, OriginData originData)
{
var knownSamples = from distribution in distributions
select new
{
Min = new Sample(distribution.Age, distribution.MinValue.Value),
Max = new Sample(distribution.Age, distribution.MaxValue.Value),
};
knownSamples = knownSamples.ToList();
parameter.Parameter(Constants.Distribution.MINIMUM).Value = _interpolation.Interpolate(knownSamples.Select(item => item.Min), originData.Age.Value);
parameter.Parameter(Constants.Distribution.MAXIMUM).Value = _interpolation.Interpolate(knownSamples.Select(item => item.Max), originData.Age.Value);
parameter.IsFixedValue = false;
}
public IDistributionFormula CreateFor(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, OriginData originData)
{
UpdateDistributionBasedOn(distributions, parameter, null, originData);
return(_distributionFormulaFactory.CreateUniformDistributionFormulaFor(parameter, parameter.Parameter(Constants.Distribution.MINIMUM), parameter.Parameter(Constants.Distribution.MAXIMUM)));
}
private ParameterDistributionMetaData closestDistributionMetaDataFor(IReadOnlyList <ParameterDistributionMetaData> distributions, OriginData originData)
{
if (!originData.Age.HasValue)
{
return(distributions.First());
}
var samples = distributions.Select(x => new Sample <ParameterDistributionMetaData>(x.Age, x));
return(_interpolation.Interpolate(samples, originData.Age.Value));
}
public IDistributedParameter CreateFor(IReadOnlyList <ParameterDistributionMetaData> distributions, OriginData originData)
{
return(create(closestDistributionMetaDataFor(distributions, originData), p => _formulaFactory.DistributionFor(distributions, p, originData)));
}
public MoBiPopulation()
{
_originData = new OriginData();
}
public Individual CreateStandardFor(OriginData originData)
{
return(createStandardIndividual(originData, x => x.CreateModelFor));
}
public IDistributionFormula CreateFor(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, OriginData originData)
{
throw new PKSimException("Should not be called");
}
private static bool isRealPreterm(OriginData originData)
{
return(originData.GestationalAge.GetValueOrDefault(CoreConstants.NOT_PRETERM_GESTATIONAL_AGE_IN_WEEKS) < CoreConstants.NOT_PRETERM_GESTATIONAL_AGE_IN_WEEKS);
}
public void UpdateDistributionBasedOn(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, IDistributedParameter baseParameter, OriginData originData)
{
var allDistributions = distributions.ToList();
foreach (var factory in _allDistributionFactory)
{
if (!factory.IsSatisfiedBy(allDistributions))
{
continue;
}
factory.UpdateDistributionBasedOn(allDistributions, parameter, baseParameter, originData);
return;
}
}
public IDistributionFormula CreateFor(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, OriginData originData)
{
var allDistributions = distributions.ToList();
foreach (var factory in _allDistributionFactory)
{
if (factory.IsSatisfiedBy(allDistributions))
{
return(factory.CreateFor(allDistributions, parameter, originData));
}
}
throw new DistributionNotFoundException(parameter, _reportGenerator.StringReportFor(originData));
}
public void UpdateDistributionBasedOn(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, IDistributedParameter baseParameter, OriginData originData)
{
var knownSamples = from distribution in distributions
select new
{
Mean = new Sample(distribution.Age, distribution.Mean),
Std = new Sample(distribution.Age, distribution.Deviation)
};
knownSamples = knownSamples.ToList();
parameter.MeanParameter.Value = _interpolation.Interpolate(knownSamples.Select(item => item.Mean), originData.Age.Value);
parameter.DeviationParameter.Value = _interpolation.Interpolate(knownSamples.Select(item => item.Std), originData.Age.Value);
parameter.ScaleDistributionBasedOn(baseParameter);
}
public IDistributionFormula CreateFor(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, OriginData originData)
{
UpdateDistributionBasedOn(distributions, parameter, null, originData);
return(_distributionFormulaFactory.CreateLogNormalDistributionFormulaFor(parameter, parameter.MeanParameter, parameter.DeviationParameter));
}
public void UpdateDistributionBasedOn(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameter, IDistributedParameter baseParameter, OriginData originData)
{
var knownSamples = from distribution in distributions
select new Sample(distribution.Age, distribution.Mean);
parameter.MeanParameter.Value = _interpolation.Interpolate(knownSamples, originData.Age.Value);
this.ScaleDistributionFor(parameter, baseParameter);
parameter.IsFixedValue = false;
}
public static IReadOnlyList <ParameterDistributionMetaData> DefinedFor(this IEnumerable <ParameterDistributionMetaData> allMetaData, OriginData originData)
{
var allValidMetaData = new List <ParameterDistributionMetaData>();
foreach (var metaDataForParameter in allMetaData.GroupBy(x => x.ParameterName))
{
var allNonPreterm = metaDataForParameter.allForGA(CoreConstants.NOT_PRETERM_GESTATIONAL_AGE_IN_WEEKS).ToList();
if (!isRealPreterm(originData))
{
allValidMetaData.AddRange(allNonPreterm);
}
else
{
var allForGestationalAge = metaDataForParameter.allForGA(originData.GestationalAge).ToList();
if (allForGestationalAge.Any())
{
allValidMetaData.AddRange(allForGestationalAge);
allValidMetaData.AddRange(addMissingAgeForGA(allNonPreterm, allForGestationalAge));
}
else
{
allValidMetaData.AddRange(allNonPreterm);
}
}
}
return(allValidMetaData);
}
public IDistributionFormula DistributionFor(IEnumerable <ParameterDistributionMetaData> distributions, IDistributedParameter parameterWithDistribution, OriginData originData)
{
return(_distributionFactory.CreateFor(distributions, parameterWithDistribution, originData));
}
private void addNeighborhood(INeighborhoodBuilder neighborhood, ISpatialStructure spatialStructure, OriginData originData, ModelProperties modelProperties, IFormulaCache formulaCache)
{
spatialStructure.AddNeighborhood(neighborhood);
_parameterContainerTask.AddModelParametersTo(neighborhood, originData, modelProperties, formulaCache);
_parameterContainerTask.AddModelParametersTo(neighborhood.MoleculeProperties, originData, modelProperties, formulaCache);
}
public IDistributedParameter CreateFor(IEnumerable <ParameterDistributionMetaData> distributions, OriginData originData)
{
var dist = distributions.ToList();
return(create(dist.First(), p => _formulaFactory.DistributionFor(dist, p, originData)));
}
