protected override ISpatialStructure CreateSpatialStructure()
{
var spatialStructure = _objectBaseFactory.Create <IMoBiSpatialStructure>();
spatialStructure.DiagramManager = _diagramManagerFactory.Create <ISpatialStructureDiagramManager>();
return(spatialStructure);
}
protected override void Context()
{
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_rateObjectPathsRepository = A.Fake <IRateObjectPathsRepository>();
_rateFormulaRepository = A.Fake <IRateFormulaRepository>();
_distributionFactory = A.Fake <IDistributionFormulaFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_timeDimension = A.Fake <IDimension>();
_idGenerator = A.Fake <IIdGenerator>();
A.CallTo(() => _objectBaseFactory.Create <ExplicitFormula>()).Returns(new ExplicitFormula());
A.CallTo(() => _objectBaseFactory.Create <ConstantFormula>()).Returns(new ConstantFormula());
A.CallTo(() => _objectBaseFactory.Create <SumFormula>()).Returns(new SumFormula());
A.CallTo(() => _dimensionRepository.Time).Returns(_timeDimension);
_objectPathFactory = new ObjectPathFactoryForSpecs();
_dynamicFormulaCriteriaRepo = A.Fake <IDynamicFormulaCriteriaRepository>();
_dynamicSumFormulaRateKey = new RateKey(CoreConstants.CalculationMethod.DynamicSumFormulas, "SomeFormula");
_sumFormulaCriteria = new DescriptorCriteria();
_sumFormulaCriteria.Add(new MatchTagCondition("xxx"));
_sumFormulaCriteria.Add(new NotMatchTagCondition("yyy"));
A.CallTo(() => _dynamicFormulaCriteriaRepo.CriteriaFor(_dynamicSumFormulaRateKey)).Returns(_sumFormulaCriteria);
A.CallTo(() => _rateFormulaRepository.FormulaFor(_dynamicSumFormulaRateKey)).Returns("P_#i");
sut = new FormulaFactory(_objectBaseFactory, _rateObjectPathsRepository, _rateFormulaRepository, _distributionFactory,
_objectPathFactory, _dimensionRepository, _idGenerator, _dynamicFormulaCriteriaRepo);
}
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.Parameter.AGE, originData.Age, originData.AgeUnit);
setParameter(individual, CoreConstants.Parameter.GESTATIONAL_AGE, originData.GestationalAge, originData.GestationalAgeUnit, individual.IsPreterm);
setParameter(individual, CoreConstants.Parameter.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.Parameter.BMI, originData.BMIUnit);
setParameterDisplayUnit(individual, CoreConstants.Parameter.WEIGHT, originData.WeightUnit);
_ontogenyVariabilityUpdater.UpdatePlasmaProteinsOntogenyFor(individual);
//update ontogeny parameters
validate(individual);
individual.IsLoaded = true;
return(individual);
}
public ISpatialStructure CreateFor(Individual individual, Simulation simulation)
{
var spatialStructure = Create().WithName(simulation.Name);
var organism = _objectBaseFactory.Create <Organism>();
spatialStructure.AddTopContainer(organism);
var eventContainer = _objectBaseFactory.Create <IContainer>()
.WithName(Constants.EVENTS)
.WithMode(ContainerMode.Logical);
spatialStructure.AddTopContainer(eventContainer);
//FIRST: Global molecule parameters
addModelStructureTo(spatialStructure.GlobalMoleculeDependentProperties, individual.OriginData, simulation.ModelProperties, spatialStructure.FormulaCache);
//SECOND: Then, individual structure
addModelStructureTo(organism, individual.OriginData, simulation.ModelProperties, spatialStructure.FormulaCache);
addNeighborhoods(spatialStructure, organism, individual, simulation.ModelProperties, spatialStructure.FormulaCache);
//THIRD: update parameter values and ids
updateParameterFromIndividual(spatialStructure, individual);
return(spatialStructure);
}
private void setupParticleBin(IApplicationBuilder applicBuilder, int binIndex, double binRadius, double binNumberOfParticlesFactor, IFormulaCache formulaCache)
{
var binName = binContainerName(binIndex);
var binContainer = applicBuilder.GetSingleChildByName <IContainer>(binName);
var numberOfParticlesFactor = binContainer.Parameter(CoreConstants.Parameters.NUMBER_OF_PARTICLES_FACTOR);
numberOfParticlesFactor.Value = binNumberOfParticlesFactor;
var particleRadius = binContainer.Parameter(CoreConstants.Parameters.START_PARTICLE_RADIUS);
particleRadius.Value = binRadius;
// add application molecule in particle bin and set its formula
var appMoleculeBuilder = _objectBaseFactory.Create <IApplicationMoleculeBuilder>().WithName(solubleMoleculeName(binIndex));
appMoleculeBuilder.RelativeContainerPath = _objectPathFactory.CreateObjectPathFrom(binName);
appMoleculeBuilder.Formula = particleDrugMassFormula(formulaCache);
applicBuilder.AddMolecule(appMoleculeBuilder);
// add insoluble molecule for particle bin
appMoleculeBuilder = _objectBaseFactory.Create <IApplicationMoleculeBuilder>().WithName(insolubleMoleculeName(binIndex));
appMoleculeBuilder.RelativeContainerPath = _objectPathFactory.CreateObjectPathFrom(binName, CoreConstants.ContainerName.InsolubleDrug);
appMoleculeBuilder.Formula = insolubleDrugStartFormula(formulaCache);
applicBuilder.AddMolecule(appMoleculeBuilder);
}
public PopulationSimulationImport ImportFromPopulationFile(string simulationFile, string populationFile)
{
var populationSimulationImport = populationSimulationImportFrom(simulationFile);
var cache = _individualPropertiesCacheImporter.ImportFrom(populationFile, populationSimulationImport);
if (populationSimulationImport.Status.Is(NotificationType.Error))
{
return(populationSimulationImport);
}
var population = _objectBaseFactory.Create <MoBiPopulation>();
population.SetNumberOfItems(cache.Count);
var populationSimulation = populationSimulationImport.PopulationSimulation;
var allParameters = _parameterRetriever.ParametersFrom(populationSimulation);
foreach (var parameterPath in cache.AllParameterPaths())
{
var parameter = allParameters[parameterPath];
if (parameter != null)
{
populationSimulation.ParameterValuesCache.Add(cache.ParameterValuesFor(parameterPath));
addAdvancedParameterIfRequired(parameter, populationSimulation);
}
else
{
populationSimulationImport.AddWarning(PKSimConstants.Warning.ParameterPathNotFoundInSimulationAndWillBeIgnored(parameterPath));
}
}
return(addPopulationToPopulationSimulation(populationSimulationImport, population));
}
protected override void Context()
{
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_simulationBuildingBlockUpdater = A.Fake <ISimulationBuildingBlockUpdater>();
_simulationModelCreator = A.Fake <ISimulationModelCreator>();
_simulationParametersUpdater = A.Fake <ISimulationParametersUpdater>();
_modelPropertiesTask = A.Fake <IModelPropertiesTask>();
_cloner = A.Fake <ICloner>();
_diagramModelFactory = A.Fake <IDiagramModelFactory>();
_interactionTask = A.Fake <IInteractionTask>();
_individual = A.Fake <Individual>();
_compounds = new List <Compound>();
A.CallTo(() => _individual.BuildingBlockType).Returns(PKSimBuildingBlockType.Individual);
_population = A.Fake <Population>();
A.CallTo(() => _population.BuildingBlockType).Returns(PKSimBuildingBlockType.Population);
_originData = new OriginData();
_modelProperties = A.Fake <ModelProperties>();
_individualSimulation = A.Fake <IndividualSimulation>();
_populationSimulation = A.Fake <PopulationSimulation>();
_objectIdResetter = A.Fake <IObjectIdResetter>();
_compoundPropertiesUpdater = A.Fake <ICompoundPropertiesUpdater>();
A.CallTo(() => _objectBaseFactory.Create <IndividualSimulation>()).Returns(_individualSimulation);
A.CallTo(() => _objectBaseFactory.Create <PopulationSimulation>()).Returns(_populationSimulation);
_individual.OriginData = _originData;
A.CallTo(() => _individual.Organism).Returns(A.Fake <Organism>());
sut = new SimulationFactory(_objectBaseFactory,
_simulationBuildingBlockUpdater, _simulationModelCreator, _objectIdResetter, _compoundPropertiesUpdater, _simulationParametersUpdater,
_modelPropertiesTask, _cloner, _diagramModelFactory, _interactionTask);
}
private IObserverBuilder createObserverBuilderByType(FlatObserver flatObserver)
{
if (flatObserver.BuilderType == ObserverBuilderType.Amount)
{
var amountObserverBuilder = _entityBaseFactory.Create <IAmountObserverBuilder>();
addDescriptorConditions(amountObserverBuilder.ContainerCriteria,
ObserverTagType.PARENT, flatObserver.Name);
return(amountObserverBuilder);
}
if (flatObserver.BuilderType == ObserverBuilderType.Container)
{
var containerObserverBuilder = _entityBaseFactory.Create <IContainerObserverBuilder>();
addDescriptorConditions(containerObserverBuilder.ContainerCriteria,
ObserverTagType.PARENT, flatObserver.Name);
return(containerObserverBuilder);
}
throw new ArgumentException(PKSimConstants.Error.UnknownObserverBuilderType);
}
/// <summary>
/// Add start formula for the drug molecule. Will be created in the root application container
/// </summary>
private void addDrugStartFormula(IApplicationBuilder applicationBuilder, IFormulaCache formulaCache)
{
var appMoleculeBuilder = _objectBaseFactory.Create <IApplicationMoleculeBuilder>().WithName(applicationBuilder.Name);
appMoleculeBuilder.RelativeContainerPath = _objectPathFactory.CreateObjectPathFrom(ObjectPath.PARENT_CONTAINER, applicationBuilder.Name);
appMoleculeBuilder.Formula = drugMassFormula(formulaCache);
applicationBuilder.AddMolecule(appMoleculeBuilder);
}
private SensitivityParameter createSensitivityParameter(ParameterSelection parameterSelection = null, string nameToUse = "")
{
var sensitivityParameter = _objectBaseFactory.Create <SensitivityParameter>().WithName(nameToUse);
sensitivityParameter.ParameterSelection = parameterSelection;
addParametersTo(sensitivityParameter);
return(sensitivityParameter);
}
private TSimulation create <TSimulation>() where TSimulation : Simulation
{
var simulation = _objectBaseFactory.Create <TSimulation>();
simulation.Properties = new SimulationProperties();
simulation.ReactionDiagramModel = _diagramModelFactory.Create();
simulation.IsLoaded = true;
return(simulation);
}
private RandomPopulation createPopulationFor(RandomPopulationSettings populationSettings)
{
var randomPopulation = _objectBaseFactory.Create <RandomPopulation>();
randomPopulation.Root = _objectBaseFactory.Create <IRootContainer>();
randomPopulation.Settings = populationSettings;
randomPopulation.SetAdvancedParameters(_objectBaseFactory.Create <IAdvancedParameterCollection>());
return(randomPopulation);
}
private ImportPopulation createPopulationFor(Individual individual)
{
var importPopulation = _objectBaseFactory.Create <ImportPopulation>();
importPopulation.Root = _objectBaseFactory.Create <IRootContainer>();
importPopulation.SetAdvancedParameters(_objectBaseFactory.Create <IAdvancedParameterCollection>());
importPopulation.Settings.BaseIndividual = _cloner.Clone(individual);
importPopulation.IsLoaded = true;
return(importPopulation);
}
public Compound Create()
{
var compound = _objectBaseFactory.Create <Compound>();
compound.Root = _objectBaseFactory.Create <IRootContainer>();
readCompoundFromTemplate(compound);
initializeCalculationMethods(compound);
compound.IsLoaded = true;
return(compound);
}
public ParameterAlternative CreateAlternativeFor(ParameterAlternativeGroup compoundParameterGroup)
{
var alternative = createAlternativeFor(compoundParameterGroup);
//for alternative that are not the default one, and if the groups requires it, we reset the formula to a constant value
if (groupHasCalculatedAlternative(compoundParameterGroup))
{
alternative.AllParameters().Each(p => p.Formula = _objectBaseFactory.Create <ConstantFormula>().WithValue(0));
}
return(alternative);
}
protected TMolecule CreateMolecule(string moleculeName)
{
var molecule = _objectBaseFactory.Create <TMolecule>().WithIcon(Icon.IconName).WithName(moleculeName);
CreateMoleculeParameterIn(molecule, REFERENCE_CONCENTRATION, CoreConstants.DEFAULT_REFERENCE_CONCENTRATION_VALUE);
CreateMoleculeParameterIn(molecule, HALF_LIFE_LIVER, CoreConstants.DEFAULT_MOLECULE_HALF_LIFE_LIVER_VALUE_IN_MIN);
CreateMoleculeParameterIn(molecule, HALF_LIFE_INTESTINE, CoreConstants.DEFAULT_MOLECULE_HALF_LIFE_INTESTINE_VALUE_IN_MIN);
CreateMoleculeParameterIn(molecule, DISEASE_FACTOR, CoreConstants.DEFAULT_DISEASE_FACTOR);
return(molecule);
}
public OutputInterval Create(double startTimeInMinute, double endTimeInMinute, double resolutionInPtsPerMin)
{
var interval = _objectBaseFactory.Create <OutputInterval>();
interval.Add(createParameter(Constants.Parameters.START_TIME, Constants.Dimension.TIME, startTimeInMinute));
interval.Add(createParameter(Constants.Parameters.END_TIME, Constants.Dimension.TIME, endTimeInMinute));
interval.Add(createParameter(Constants.Parameters.RESOLUTION, Constants.Dimension.RESOLUTION, resolutionInPtsPerMin));
interval.Resolution.MinIsAllowed = false;
return(interval);
}
private IParameter createParameter(string name)
{
var parameter = _objectBaseFactory.Create <IParameter>()
.WithName(name)
.WithFormula(_objectBaseFactory.Create <ConstantFormula>());
parameter.Editable = true;
parameter.CanBeVaried = false;
parameter.Visible = true;
return(parameter);
}
protected override void Context()
{
base.Context();
_returnedBuildingBlocks = new List <IBuildingBlock>();
_childReactionBuilder = new ReactionBuilder().WithName("Test").WithId("FindME");
_reactionParameter = new Parameter().WithName("Para").WithId("ReactionPara");
_childReactionBuilder.AddParameter(_reactionParameter);
_reactionBuildingBlock = new MoBiReactionBuildingBlock()
{
_childReactionBuilder
};
_allBuildingBlocks.Add(_reactionBuildingBlock);
_moleculeBuilder = new MoleculeBuilder();
_moleculeParameter = new Parameter().WithName("para");
_moleculeBuilder.AddParameter(_moleculeParameter);
_moleculeBuildingBlock = new MoleculeBuildingBlock()
{
_moleculeBuilder
};
_allBuildingBlocks.Add(_moleculeBuildingBlock);
_passiveTranportBuilder = new TransportBuilder();
_passiveTransportParameter = new Parameter().WithName("PTParameter");
_passiveTranportBuilder.AddParameter(_passiveTransportParameter);
_passiveTranportBuildingBlock = new PassiveTransportBuildingBlock()
{
_passiveTranportBuilder
};
_allBuildingBlocks.Add(_passiveTranportBuildingBlock);
_applicationBuilder = new ApplicationBuilder();
_eventGroupBuildingBlock = new EventGroupBuildingBlock()
{
_applicationBuilder
};
_applicationBuilderParameter = new ApplicationBuilder().WithName("AppParameter");
_applicationBuilder.Add(_applicationBuilderParameter);
_allBuildingBlocks.Add(_eventGroupBuildingBlock);
_parameter = new Parameter().WithName("Para");
var container = new Container().WithName("Cont");
container.Add(_parameter);
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_parameterFactory = A.Fake <IParameterFactory>();
A.CallTo(() => _objectBaseFactory.Create <IContainer>()).Returns(new Container());
A.CallTo(() => _objectBaseFactory.Create <IMoBiSpatialStructure>()).Returns(new MoBiSpatialStructure());
var diagramManagerFactory = A.Fake <IDiagramManagerFactory>();
_spatialStructure = new MoBiSpatialStructureFactory(_objectBaseFactory, _parameterFactory, A.Fake <IIconRepository>(), diagramManagerFactory).Create() as IMoBiSpatialStructure;
_spatialStructure.AddTopContainer(container);
_allBuildingBlocks.Add(_spatialStructure);
_formula = new ExplicitFormula();
_moleculeBuildingBlock.AddFormula(_formula);
}
protected override void Context()
{
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_parameterFactory = A.Fake <IParameterFactory>();
_iconRepository = A.Fake <IIconRepository>();
_volumeParameter = A.Fake <IParameter>().WithName(Constants.Parameters.VOLUME);
A.CallTo(() => _parameterFactory.CreateVolumeParameter()).Returns(_volumeParameter);
_spatialStructure = new MoBiSpatialStructure();
A.CallTo(() => _objectBaseFactory.Create <IMoBiSpatialStructure>()).Returns(_spatialStructure);
A.CallTo(() => _objectBaseFactory.Create <IContainer>()).ReturnsLazily(x => new Container());
_diagramManagerFactory = A.Fake <IDiagramManagerFactory>();
sut = new MoBiSpatialStructureFactory(_objectBaseFactory, _parameterFactory, _iconRepository, _diagramManagerFactory);
}
private IReactionBuildingBlock getReactions()
{
var reactions = _objectBaseFactory.Create <IReactionBuildingBlock>();
var R1 = _objectBaseFactory.Create <IReactionBuilder>()
.WithName("R1")
.WithKinetic(R1Formula(reactions.FormulaCache))
.WithDimension(_concentrationPerTimeDimension);
R1.AddEduct(new ReactionPartnerBuilder("A", 1));
R1.AddProduct(new ReactionPartnerBuilder("B", 1));
reactions.Add(R1);
return(reactions);
}
public IObserverBuildingBlock AllObserversFor(IMoleculeBuildingBlock moleculeBuildingBlock, Simulation simulation)
{
var observerBuildingBlock = _objectBaseFactory.Create <IObserverBuildingBlock>().WithName(simulation.Name);
addStandardObserversTo(simulation, observerBuildingBlock, moleculeBuildingBlock);
addSimulationObservers(simulation, observerBuildingBlock);
//now add dynamic observers for molecules needing one
createFractionExcretedToUrineObserver(simulation, observerBuildingBlock);
createFractionOfDoseExcretedToBileObserver(simulation, observerBuildingBlock);
createFractionOfDoseExcretedToFecesObserver(simulation, observerBuildingBlock);
//add fraction observers for metabolite and complex
createFractionOfDoseObserver(simulation, observerBuildingBlock);
foreach (var compound in simulation.Compounds)
{
foreach (var specificBinding in simulation.CompoundPropertiesFor(compound).Processes.SpecificBindingSelection.AllEnabledProcesses())
{
var complexName = specificBinding.ProductName(CoreConstants.Molecule.Complex);
var protein = moleculeBuildingBlock[specificBinding.MoleculeName];
var complex = moleculeBuildingBlock[complexName];
createReceptorOccupancyObserver(observerBuildingBlock, protein, complex);
}
}
return(observerBuildingBlock);
}
protected override Task Context()
{
_descriptorConditionMapper = A.Fake <DescriptorConditionMapper>();
_explicitFormulaMapper = A.Fake <ExplicitFormulaMapper>();
_moleculeListMapper = A.Fake <MoleculeListMapper>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_logger = A.Fake <ILogger>();
_dimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_amountObserver = new AmountObserverBuilder {
Dimension = _dimension
};
_containerObserver = new ContainerObserverBuilder {
Dimension = _dimension
};
_formula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("1+2");
_amountObserver.Formula = _formula;
_containerObserver.Formula = _formula;
_moleculeListSnapshot = new MoleculeList();
_snapshotFormula = new ExplicitFormula();
_newMoleculeList = new OSPSuite.Core.Domain.Builder.MoleculeList();
_newMoleculeList.AddMoleculeNameToExclude("A");
_newMoleculeList.AddMoleculeName("B");
_newMoleculeList.ForAll = false;
_newFormula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("New");
sut = new ObserverMapper(
_descriptorConditionMapper,
_explicitFormulaMapper,
_moleculeListMapper,
_objectBaseFactory,
_dimensionRepository,
_logger);
A.CallTo(() => _explicitFormulaMapper.MapToSnapshot(_formula)).Returns(_snapshotFormula);
A.CallTo(() => _explicitFormulaMapper.MapToModel(_snapshotFormula)).Returns(_newFormula);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_amountObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_containerObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToModel(_moleculeListSnapshot)).Returns(_newMoleculeList);
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
A.CallTo(() => _objectBaseFactory.Create <AmountObserverBuilder>()).Returns(new AmountObserverBuilder());
A.CallTo(() => _objectBaseFactory.Create <ContainerObserverBuilder>()).Returns(new ContainerObserverBuilder());
return(_completed);
}
private void addEffectiveSurfaceAreaParameter(ISpatialStructure spatialStructure)
{
var organism = getOrganism(spatialStructure);
if (organism == null)
{
return;
}
var lumen = organism.EntityAt <IContainer>("Lumen");
if (lumen == null)
{
return;
}
var variabilityFactor = lumen.EntityAt <IParameter>(EFFECTIVE_SURFACE_AREA_VARIABILITY_FACTOR);
var area = _dimensionFactory.Dimension("Area");
foreach (var containerWithSurfaceArea in organism.GetAllChildren <IContainer>(c => c.ContainsName(EFFECTIVE_SURFACE_AREA_ENHANCEMENT_FACTOR)))
{
var effectiveSurfaceArea = _objectBaseFactory.Create <IParameter>()
.WithName(EFFECTIVE_SURFACE_AREA)
.WithDimension(area)
.WithGroup("GI_ANATOMY_AREA")
.WithDescription("Effective surface area of GI segment");
var geometricSurfaceArea = containerWithSurfaceArea.EntityAt <IParameter>(GEOMETRIC_SURFACE_AREA);
if (geometricSurfaceArea == null)
{
continue;
}
var effectiveSurfaceAreaEnahncementFactor = containerWithSurfaceArea.EntityAt <IParameter>(EFFECTIVE_SURFACE_AREA_ENHANCEMENT_FACTOR);
containerWithSurfaceArea.Add(effectiveSurfaceArea);
var formula = spatialStructure.FormulaCache.FindByName("PARAM_EffectiveSurfaceArea") as ExplicitFormula;
if (formula == null)
{
formula = _formulaTask.CreateNewFormula <ExplicitFormula>(area).WithName("PARAM_EffectiveSurfaceArea");
formula.AddObjectPath(_objectPathFactory.CreateRelativeFormulaUsablePath(effectiveSurfaceArea, variabilityFactor).WithAlias("AeffVariabilityFactor"));
formula.AddObjectPath(_objectPathFactory.CreateRelativeFormulaUsablePath(effectiveSurfaceArea, geometricSurfaceArea).WithAlias("Ageom"));
formula.AddObjectPath(_objectPathFactory.CreateRelativeFormulaUsablePath(effectiveSurfaceArea, effectiveSurfaceAreaEnahncementFactor).WithAlias("AeffFactor"));
formula.FormulaString = "Ageom * AeffFactor * AeffVariabilityFactor";
spatialStructure.AddFormula(formula);
}
effectiveSurfaceArea.Formula = formula;
}
}
protected TMolecule CreateEmptyMolecule()
{
var molecule = _objectBaseFactory.Create <TMolecule>().WithIcon(Icon.IconName);
createMoleculeParameterIn(molecule, CoreConstants.Parameters.REFERENCE_CONCENTRATION, CoreConstants.DEFAULT_REFERENCE_CONCENTRATION_VALUE, Constants.Dimension.MOLAR_CONCENTRATION);
createMoleculeParameterIn(molecule, CoreConstants.Parameters.HALF_LIFE_LIVER, CoreConstants.DEFAULT_MOLECULE_HALF_LIFE_LIVER_VALUE_IN_MIN, Constants.Dimension.TIME);
createMoleculeParameterIn(molecule, CoreConstants.Parameters.HALF_LIFE_INTESTINE, CoreConstants.DEFAULT_MOLECULE_HALF_LIFE_INTESTINE_VALUE_IN_MIN, Constants.Dimension.TIME);
foreach (var parameterName in CoreConstants.Parameters.OntogenyFactors)
{
createMoleculeParameterIn(molecule, parameterName, 1, Constants.Dimension.DIMENSIONLESS, CoreConstants.Groups.ONTOGENY_FACTOR, canBeVariedInPopulation: false);
}
return(molecule);
}
private RandomPopulation createPopulationFor(RandomPopulationSettings populationSettings, int?seed)
{
var randomPopulation = _objectBaseFactory.Create <RandomPopulation>();
randomPopulation.Root = _objectBaseFactory.Create <IRootContainer>();
randomPopulation.Settings = populationSettings;
randomPopulation.SetAdvancedParameters(_objectBaseFactory.Create <AdvancedParameterCollection>());
if (seed != null)
{
randomPopulation.Seed = seed.Value;
}
return(randomPopulation);
}
public IFormula BMIFormulaFor(IParameter weightParameter, IParameter heightParameter)
{
const string height = "Height";
const string weight = "BW";
var formula = _objectBaseFactory.Create <ExplicitFormula>()
.WithName(CoreConstants.Parameter.BMI)
.WithFormulaString($"{height}>0 ? {weight} / ({height})^2 : 0")
.WithDimension(_dimensionRepository.BMI);
formula.AddObjectPath(pathInParentContainerFor(weightParameter, weight));
formula.AddObjectPath(pathInParentContainerFor(heightParameter, height));
return(formula);
}
public Formulation MapFrom(FlatContainer flatContainer)
{
var formulation = _objectBaseFactory.Create <Formulation>();
formulation.Root = _objectBaseFactory.Create <IRootContainer>();
formulation.Name = flatContainer.Name;
//save formulation name as formulation type too,
//because name can be overwritten by user
formulation.FormulationType = formulation.Name;
foreach (var formulationRoute in _formulationRouteRepo.All().Where(fr => fr.Formulation.Equals(formulation.Name)))
{
formulation.AddRoute(formulationRoute.Route);
}
return(formulation);
}
protected override void DoStart()
{
var moleculeWithDefinedOntogenies = (from flatOntogeny in _flatOntogenyRepository.All()
select new
{
flatOntogeny.MoleculeName,
flatOntogeny.SpeciesName,
flatOntogeny.DisplayName,
}
).Distinct();
foreach (var moleculeWithOntogeny in moleculeWithDefinedOntogenies)
{
var newOntogeny = _objectBaseFactory.Create <DatabaseOntogeny>().WithName(moleculeWithOntogeny.MoleculeName);
newOntogeny.SpeciesName = moleculeWithOntogeny.SpeciesName;
newOntogeny.DisplayName = moleculeWithOntogeny.DisplayName;
_allOntogenies.Add(newOntogeny);
//cache ontogeny values using {Enzyme name, species name} as key
var ontogeny = moleculeWithOntogeny;
var allOntogenies = from flatOntogeny in _flatOntogenyRepository.All()
where flatOntogeny.MoleculeName.Equals(ontogeny.MoleculeName)
where flatOntogeny.SpeciesName.Equals(ontogeny.SpeciesName)
select flatOntogeny;
_ontogenyValues.Add(ontogenyKey(ontogeny.MoleculeName, ontogeny.SpeciesName), allOntogenies.ToList());
}
}
protected override void Context()
{
var organism = new Container().WithName("Organism");
_objectPathFactory = new ObjectPathFactory(new AliasCreator());
_fuParameter = new Parameter().WithName("fu").WithValue(0.5);
organism.Add(_fuParameter);
var liver = new Container().WithName("Liver").WithParentContainer(organism);
var liverVolume = new Parameter().WithName("Volume").WithValue(10).WithParentContainer(liver);
var f_vas_liver = new Parameter().WithName("f_vas").WithValue(0.1);
liver.Add(f_vas_liver);
var kidney = new Container().WithName("Kidney").WithParentContainer(organism);
var kidneyVolume = new Parameter().WithName("Volume").WithValue(20).WithParentContainer(kidney);
kidney.Add(new Parameter().WithName("f_vas").WithValue(0.2));
sut = new SumFormula();
sut.Criteria = Create.Criteria(x => x.With("Volume"));
sut.Variable = "V";
sut.FormulaString = "fu * V_#i * f_vas_#i";
sut.AddObjectPath(_objectPathFactory.CreateRelativeFormulaUsablePath(liverVolume, f_vas_liver).WithAlias("f_vas_#i"));
sut.AddObjectPath(_objectPathFactory.CreateAbsoluteFormulaUsablePath(_fuParameter).WithAlias("fu"));
sut.Dimension = new Dimension(new BaseDimensionRepresentation(), "dim1", "unit1");
_allFormulaUsable = organism.GetAllChildren <IFormulaUsable>().ToEntityDescriptorMapList();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
A.CallTo(() => _objectBaseFactory.Create <ExplicitFormula>()).Returns(new ExplicitFormula());
}
