private IEnumerable <IParameterStartValue> getMoleculeParameterValues(ISpatialStructure spatialStructure, IMoleculeBuilder moleculeBuilder)
{
return(moleculeBuilder.Parameters.Where(parameterValueShouldBeSet)
//"Property"-Parameter are defined in the molecule itself
.Where(x => x.BuildMode != ParameterBuildMode.Property)
.SelectMany(x => getMoleculeParameterValue(spatialStructure, moleculeBuilder, x)));
}
protected override void Context()
{
base.Context();
_objectBase = new Container();
_objectBase.Name = _changedName;
_spatialStructure = new SpatialStructure().WithName("Org").WithId("Org").WithTopContainer(_objectBase);
}
private void updateForPKSimChanges(ISpatialStructure spatialStructure)
{
if (canAddNewParametersTo(spatialStructure))
{
var blood2PlasmaFormula = createBlood2PlasmaFormula();
var mucosaPermeabilityScaleFactorTranscellularFormula = createMucosaPermeabilityScaleFactor_transcellularFormula();
var defaultIntestinalPermeabilityTranscellularFormula = creteDefaultIntestinalPermeabilityTranscellularFormula();
spatialStructure.AddFormula(blood2PlasmaFormula);
spatialStructure.AddFormula(mucosaPermeabilityScaleFactorTranscellularFormula);
spatialStructure.AddFormula(defaultIntestinalPermeabilityTranscellularFormula);
spatialStructure.GlobalMoleculeDependentProperties.Add(createBlood2PlasmaRatioParameter(blood2PlasmaFormula));
spatialStructure.GlobalMoleculeDependentProperties.Add(createMucosaPermeabilityScaleFactorTranscellularParameter(mucosaPermeabilityScaleFactorTranscellularFormula));
spatialStructure.GlobalMoleculeDependentProperties.Add(createDefaultIntestinalPermeabilityTranscellularParameter(defaultIntestinalPermeabilityTranscellularFormula));
}
if (is2PoreModel(spatialStructure))
{
var moleculeProperties = spatialStructure.NeighborhoodsContainer.GetSingleChildByName <IContainer>("EndogenousIgG_int_EndogenousIgG_pls").GetSingleChildByName <IContainer>(Constants.MOLECULE_PROPERTIES);
if (moleculeProperties == null)
{
return;
}
var partitionCoefficient =
moleculeProperties.GetSingleChildByName <IParameter>("Partition coefficient (interstitial/plasma)");
// Change Formula to Constant
if (partitionCoefficient == null)
{
return;
}
partitionCoefficient.Formula = _objectBaseFactory.Create <ConstantFormula>().WithValue(1);
}
}
protected override void Context()
{
base.Context();
_organism = new Organism();
_anotherTopContainer = new Container().WithName("Another container");
_spatialStructure = new PKSimSpatialStructure();
_spatialStructure.AddTopContainer(_organism);
_spatialStructure.AddTopContainer(_anotherTopContainer);
_ga = DomainHelperForSpecs.ConstantParameterWithValue().WithName(Constants.Parameters.GESTATIONAL_AGE);
_age = DomainHelperForSpecs.ConstantParameterWithValue().WithName(CoreConstants.Parameters.AGE);
_height = DomainHelperForSpecs.ConstantParameterWithValue().WithName(CoreConstants.Parameters.HEIGHT);
_distributedParameter = DomainHelperForSpecs.NormalDistributedParameter(isDefault: false, distributionParameterIsDefault: false).WithName("Distributed");
_p1 = DomainHelperForSpecs.ConstantParameterWithValue().WithName("P1");
_p2 = DomainHelperForSpecs.ConstantParameterWithValue().WithName("P2");
_organism.Add(_ga);
_organism.Add(_age);
_organism.Add(_height);
_organism.Add(_p1);
_anotherTopContainer.Add(_p2);
_organism.Add(_distributedParameter);
_mean = _distributedParameter.Parameter(Constants.Distribution.MEAN);
_deviation = _distributedParameter.Parameter(Constants.Distribution.DEVIATION);
}
protected override void Context()
{
base.Context();
_sourceSpatialStructure = _buildConfiguration.SpatialStructure;
_sourceSpatialStructure.Version = _buildingBlockVersion;
_cloneManager = IoC.Resolve <ICloneManagerForBuildingBlock>();
}
public void Visit(ISpatialStructure spatialStructure)
{
convert(spatialStructure);
spatialStructure.TopContainers.Each(convertSpecialParametersIn);
updateForPKSimChanges(spatialStructure);
_converted = true;
}
public IParameterStartValuesBuildingBlock CreateFor(IBuildConfiguration buildConfiguration, Simulation simulation)
{
try
{
//default default parameter start values matrix
_spatialStructure = buildConfiguration.SpatialStructure;
_defaultStartValues = _parameterStartValuesCreator.CreateFrom(_spatialStructure, buildConfiguration.Molecules);
_formulaCache = _defaultStartValues.FormulaCache;
var individual = simulation.Individual;
//set the relative expression values for each protein defined in individual
foreach (var protein in individual.AllMolecules <IndividualProtein>())
{
updateProteinParametersValues(protein);
}
foreach (var transporter in individual.AllMolecules <IndividualTransporter>())
{
updateTransporterParameterValues(transporter);
}
updateSimulationParameters(simulation);
return(_defaultStartValues.WithName(simulation.Name));
}
finally
{
_spatialStructure = null;
_defaultStartValues = null;
_formulaCache = null;
}
}
private void addVariabilityParameterIn(ISpatialStructure spatialStructure)
{
var organism = getOrganism(spatialStructure);
if (organism == null)
{
return;
}
var lumen = organism.EntityAt <IContainer>("Lumen");
if (lumen == null)
{
return;
}
var parameter = _objectBaseFactory.Create <IDistributedParameter>()
.WithName(EFFECTIVE_SURFACE_AREA_VARIABILITY_FACTOR)
.WithDescription("Effective surface area variability factor");
parameter.WithGroup("GI_ANATOMY_AEFF_FACTOR");
var meanParameter = effectiveSurfaceAreaMeanParameter();
var deviationParameter = effectiveSurfaceAreaDeviationParameter();
var percentileParameter = effectiveSurfaceAreaPercentileParameter();
parameter.Add(meanParameter);
parameter.Add(deviationParameter);
parameter.Add(percentileParameter);
parameter.Formula = _distributionFormulaFactory.CreateLogNormalDistributionFormulaFor(parameter, meanParameter, deviationParameter);
lumen.Add(parameter);
}
private void addMoleculeParameterValues(IParameterStartValuesBuildingBlock parameterStartValuesBuildingBlock,
ISpatialStructure spatialStructure, IEnumerable <IMoleculeBuilder> moleculeBuilderCollection)
{
foreach (var paramValue in moleculeBuilderCollection.SelectMany(moleculeBuilder => getMoleculeParameterValues(spatialStructure, moleculeBuilder)))
{
parameterStartValuesBuildingBlock.Add(paramValue);
}
}
protected override void Context()
{
base.Context();
_container = new Container();
_buildingBlock = new SpatialStructure();
_buildingBlock.AddTopContainer(_container);
_container.Add(_parameterOrganism);
_buildingBlock.AddFormula(_parameterOrganism.Formula);
}
protected override void Context()
{
sut = new ParameterResolver();
_moleculeBuildingBlock = new MoleculeBuildingBlock();
_spatialStructure = new SpatialStructure {
GlobalMoleculeDependentProperties = new Container()
};
_containerPath = new ObjectPath();
}
public SpatialStructureDTO MapFrom(ISpatialStructure spatialStructure)
{
var dto = Map <SpatialStructureDTO>(spatialStructure);
dto.TopContainer = spatialStructure.TopContainers.MapAllUsing(_containerToDTOContainerMapper);
dto.Neighborhoods = _containerToDTOContainerMapper.MapFrom(spatialStructure.NeighborhoodsContainer);
dto.MoleculeProperties = _containerToDTOContainerMapper.MapFrom(spatialStructure.GlobalMoleculeDependentProperties);
return(dto);
}
public void RemoveContainerFrom(ISpatialStructure spatialStructure, IContainer containerToRemove)
{
var neighborhoodBuilderToRemove = AllNeighborhoodBuildersConnectedWith(spatialStructure, containerToRemove);
foreach (var neighborhoodBuilder in neighborhoodBuilderToRemove.ToList())
{
spatialStructure.RemoveNeighborhood(neighborhoodBuilder);
}
containerToRemove.ParentContainer.RemoveChild(containerToRemove);
}
public void UpdateDefaultFor(ISpatialStructure spatialStructure)
{
var organism = spatialStructure.TopContainers.FindByName(Constants.ORGANISM);
if (organism == null)
{
return;
}
updateDefaultStateForOriginDataParameters(organism);
}
protected override void Context()
{
base.Context();
IContainer topContainer = new Container();
_testContainer = topContainer;
_testStructure = new SpatialStructure().WithTopContainer(topContainer);
_testStructure.NeighborhoodsContainer = new Container();
_testStructure.GlobalMoleculeDependentProperties = new Container();
}
public void TestComplexSpatialStructure()
{
SpatialStructure x1 = _buildConfiguration.SpatialStructure as SpatialStructure;
Assert.IsNotNull(x1);
ISpatialStructure x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualSpatialStructure(x2, x1);
}
protected override void Context()
{
base.Context();
_simulationToUpdate = A.Fake <IMoBiSimulation>();
_simulationToUpdate.Model.Name = "XX";
_templateBuildingBlock = A.Fake <ISpatialStructure>();
_updatedBuildConfiguration = A.Fake <IMoBiBuildConfiguration>();
A.CallTo(() => _configurePresenter.BuildConfiguration).Returns(_updatedBuildConfiguration);
}
public void Visit(ISpatialStructure spatialStructure)
{
foreach (var container in spatialStructure.PhysicalContainers.Where(x => !x.ContainsName(Constants.Parameters.VOLUME)).ToList())
{
container.Add(_parameterFactory.CreateVolumeParameter());
}
addVariabilityParameterIn(spatialStructure);
addEffectiveSurfaceAreaParameter(spatialStructure);
convertFormulaReferencingAeffIn(spatialStructure);
}
public static bool IsInSpatialStructure <T>(this ISpatialStructure spatialStructure, T lookFor) where T : class, IEntity
{
if (spatialStructure.Any(c => c.Equals(lookFor)))
{
return(true);
}
return(spatialStructure.Aggregate(false,
(current, topContainier) =>
current || topContainier.GetAllChildren <T>().Contains(lookFor)));
}
private void addNeighborhoods(ISpatialStructure spatialStructure, Organism organism, Individual individual, ModelProperties modelProperties, IFormulaCache formulaCache)
{
var neighborhoodList = _modelNeighborhoodQuery.NeighborhoodsFor(individual.Neighborhoods, modelProperties).ToList();
foreach (var neighborhood in neighborhoodList)
{
addNeighborhood(neighborhood, spatialStructure, individual.OriginData, modelProperties, formulaCache);
}
_neighborhoodFinalizer.SetNeighborsIn(organism, neighborhoodList);
}
private void updateParameterFromIndividual(ISpatialStructure spatialStructure, Individual individual)
{
//Update parameter values for parameter that have been changed in individual
var allIndividualParameter = new PathCache <IParameter>(_entityPathResolver).For(individual.GetAllChildren <IParameter>());
var allContainerParameters = new PathCache <IParameter>(_entityPathResolver).For(spatialStructure.TopContainers.SelectMany(x => x.GetAllChildren <IParameter>()));
var allNeighborhoodParameters = new PathCache <IParameter>(_entityPathResolver).For(spatialStructure.Neighborhoods.SelectMany(x => x.GetAllChildren <IParameter>()));
_parameterSetUpdater.UpdateValues(allIndividualParameter, allContainerParameters);
_parameterSetUpdater.UpdateValues(allIndividualParameter, allNeighborhoodParameters);
_parameterIdUpdater.UpdateBuildingBlockId(allContainerParameters, individual);
_parameterIdUpdater.UpdateBuildingBlockId(allNeighborhoodParameters, individual);
}
private bool canAddNewParametersTo(ISpatialStructure spatialStructure)
{
//spatialStructure has needed parameters, so it is assumed it is original from PK-Sim
var organism = spatialStructure.TopContainers.FirstOrDefault(tc => tc.IsNamed("Organism"));
if (organism == null)
{
return(false);
}
return
(organism.ContainsNames(new[] { "Hematocrit", "Vf (lipid, blood cells)", "Vf (protein,blood cells)", "Vf (water,blood cells)" }));
}
protected override void Context()
{
base.Context();
_spatialStructure = new SpatialStructure();
var organism = new Container().WithName(Constants.ORGANISM);
_spatialStructure.AddTopContainer(organism);
var gallbladder = new Container().WithName(Converter321To331.Gallbladder).WithParentContainer(organism);
_param = new Parameter().WithName("Volume").WithParentContainer(gallbladder);
_spatialStructure.GlobalMoleculeDependentProperties = new Container();
_spatialStructure.NeighborhoodsContainer = new Container();
}
public IMoleculeStartValuesBuildingBlock CreateFrom(ISpatialStructure spatialStructure, IMoleculeBuildingBlock moleculeBuildingBlock)
{
var moleculesStartValues = _objectBaseFactory.Create <IMoleculeStartValuesBuildingBlock>();
moleculesStartValues.SpatialStructureId = spatialStructure.Id;
moleculesStartValues.MoleculeBuildingBlockId = moleculeBuildingBlock.Id;
foreach (var container in spatialStructure.PhysicalContainers)
{
addMoleculesFrom(moleculesStartValues, container, moleculeBuildingBlock);
}
return(moleculesStartValues);
}
protected override void Context()
{
_spatialStructureFactory = A.Fake <IPKSimSpatialStructureFactory>();
_modelObserverQuery = A.Fake <IModelObserverQuery>();
_modelPassiveTransportQuery = A.Fake <IModelPassiveTransportQuery>();
_parameterStartValueCreator = A.Fake <IPKSimParameterStartValuesCreator>();
_moleculesAndReactionsCreator = A.Fake <IMoleculesAndReactionsCreator>();
_eventBuildingBlockCreator = A.Fake <IEventBuildingBlockCreator>();
_moleculeStartValueCreator = A.Fake <IPKSimMoleculeStartValuesCreator>();
_moleculeCalculationRetriever = A.Fake <IMoleculeCalculationRetriever>();
_distributedTableConverter = A.Fake <IDistributedParameterToTableParameterConverter>();
_parameterDefaultStateUpdater = A.Fake <IParameterDefaultStateUpdater>();
_cm1 = new CoreCalculationMethod();
_cm2 = new CoreCalculationMethod();
_simulation = new IndividualSimulation {
Properties = new SimulationProperties()
};
_simulation.SimulationSettings = new SimulationSettings();
_simulation.ModelConfiguration = new ModelConfiguration();
_individual = new Individual().WithName("MyIndividuyal");
_compound = A.Fake <Compound>().WithName("MyCompound");
_protocol = new SimpleProtocol().WithName("MyProtocol");
_spatialStructure = A.Fake <ISpatialStructure>();
_passiveTransportBuilingBlock = A.Fake <IPassiveTransportBuildingBlock>();
_observerBuildingBlock = A.Fake <IObserverBuildingBlock>();
_eventBuildingBlock = A.Fake <IEventGroupBuildingBlock>();
_parameterValuesBuildingBlock = A.Fake <IParameterStartValuesBuildingBlock>();
_moleculeStartValueBuildingBlock = A.Fake <IMoleculeStartValuesBuildingBlock>();
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Individual", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _individual
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Compound", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _compound
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Protocol", PKSimBuildingBlockType.Protocol)
{
BuildingBlock = _protocol
});
A.CallTo(() => _moleculeCalculationRetriever.AllMoleculeCalculationMethodsUsedBy(_simulation)).Returns(new[] { _cm1, _cm2 });
A.CallTo(() => _spatialStructureFactory.CreateFor(_individual, _simulation)).Returns(_spatialStructure);
A.CallTo(() => _modelPassiveTransportQuery.AllPassiveTransportsFor(_simulation)).Returns(_passiveTransportBuilingBlock);
A.CallTo(() => _modelObserverQuery.AllObserversFor(A <IMoleculeBuildingBlock> .Ignored, _simulation)).Returns(_observerBuildingBlock);
A.CallTo(() => _eventBuildingBlockCreator.CreateFor(_simulation)).Returns(_eventBuildingBlock);
A.CallTo(() => _parameterStartValueCreator.CreateFor(A <IBuildConfiguration> .Ignored, A <Simulation> .Ignored)).Returns(_parameterValuesBuildingBlock);
A.CallTo(() => _moleculeStartValueCreator.CreateFor(A <IBuildConfiguration> .Ignored, A <Simulation> .Ignored)).Returns(_moleculeStartValueBuildingBlock);
sut = new BuildConfigurationTask(_spatialStructureFactory, _modelObserverQuery, _modelPassiveTransportQuery, _parameterStartValueCreator,
_moleculesAndReactionsCreator, _eventBuildingBlockCreator, _moleculeStartValueCreator, _moleculeCalculationRetriever,
_distributedTableConverter, _parameterDefaultStateUpdater);
}
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;
}
}
private void addChildrenFromSpatialStructure(List <IObjectBaseDTO> children, ISpatialStructure spatialStructure)
{
if (spatialStructure == null)
{
return;
}
children.AddRange(
spatialStructure.TopContainers.ToEnumerable <IContainer, IObjectBase>()
.OrderBy(x => x.Name)
.MapAllUsing(_objectBaseDTOMapper));
children.Add(_objectBaseDTOMapper.MapFrom(spatialStructure.NeighborhoodsContainer));
addChildrenFromContainer(children, spatialStructure.GlobalMoleculeDependentProperties);
}
private IEnumerable <IObjectPath> moleculesInvolvedInExpression(ISpatialStructure spatialStructure, IndividualMolecule molecule,
IReadOnlyList <CompoundProperties> compoundPropertiesList)
{
foreach (var expressionContainer in _expressionContainersRetriever.AllContainersFor(spatialStructure, molecule))
{
var containerPath = _objectPathFactory.CreateAbsoluteObjectPath(expressionContainer);
foreach (var compoundProperties in compoundPropertiesList)
{
foreach (var moleculeName in compoundProperties.Processes.AllInducedMoleculeNames(molecule))
{
yield return(containerPath.Clone <IObjectPath>().AndAdd(moleculeName));
}
}
}
}
protected override void Context()
{
base.Context();
_spatialStructure = A.Fake <ISpatialStructure>();
_parent = A.Fake <IContainer>();
_containerToRemove = A.Fake <IContainer>();
_containerToRemove.ParentContainer = _parent;
_firstNeighborRemove = new NeighborhoodBuilder().WithFirstNeighbor(_containerToRemove).WithSecondNeighbor(A.Fake <IContainer>());
_secondNeighborRemove = new NeighborhoodBuilder().WithFirstNeighbor(A.Fake <IContainer>()).WithSecondNeighbor(_containerToRemove);
A.CallTo(() => _spatialStructure.Neighborhoods).Returns(new[]
{
new NeighborhoodBuilder().WithFirstNeighbor(A.Fake <IContainer>()).WithSecondNeighbor(A.Fake <IContainer>()),
_firstNeighborRemove,
_secondNeighborRemove
});
}
public IParameterStartValuesBuildingBlock CreateFrom(ISpatialStructure spatialStructure, IMoleculeBuildingBlock moleculeBuildingBlock)
{
var paramsStartValues = _objectBaseFactory.Create <IParameterStartValuesBuildingBlock>();
paramsStartValues.SpatialStructureId = spatialStructure.Id;
paramsStartValues.MoleculeBuildingBlockId = moleculeBuildingBlock.Id;
addMoleculeParameterValues(paramsStartValues, spatialStructure, moleculeBuildingBlock);
addTopContainersParameterValues(paramsStartValues, spatialStructure.TopContainers, moleculeBuildingBlock);
addContainerListParameterValue(paramsStartValues, spatialStructure.Neighborhoods, moleculeBuildingBlock);
addGlobalMoleculeParameterValues(paramsStartValues, spatialStructure.GlobalMoleculeDependentProperties, moleculeBuildingBlock);
return(paramsStartValues);
}
