protected override void Context() { base.Context(); _newName = "TOTO"; _f1 = new ExplicitFormula("A+B"); _f2 = new ExplicitFormula("A+B"); _f3 = new ExplicitFormula("A+B"); _f1.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell")); _f1.AddObjectPath(new FormulaUsablePath("Drug", "LogP")); _f2.AddObjectPath(new FormulaUsablePath("SU", "Liver", "Cell")); _f2.AddObjectPath(new FormulaUsablePath("Drug", "LogP")); _f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell")); _f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "LogP")); var p1 = new PKSimParameter().WithName("P1").WithFormula(_f1); var p2 = new PKSimParameter().WithName("P2").WithFormula(_f2); var p3 = new PKSimParameter().WithName("P3").WithFormula(_f3); var c1 = new Container().WithName("C1"); c1.Add(p3); _root.Add(p1); _root.Add(p2); _root.Add(c1); var results = new SimulationResults { Time = new QuantityValues { ColumnId = "0", QuantityPath = "baseGrid" } }; _individualResults = new IndividualResults { IndividualId = 1 }; results.Add(_individualResults); var quantityCache = new PathCacheForSpecs <IQuantity> { { "Liver|Cell|Drug", new MoleculeAmount { QuantityType = QuantityType.Drug } }, { "Liver|Cell|Meta", new MoleculeAmount { QuantityType = QuantityType.Metabolite } }, }; _individualResults.Add(new QuantityValues { PathList = new[] { "Liver", "Cell", "Drug" }.ToList() }); _individualResults.Add(new QuantityValues { PathList = new[] { "Liver", "Cell", "Meta" }.ToList() }); _individualSimulation.Results = results; _individualSimulation.DataRepository = new DataRepository(); _individualSimulation.Reactions = new ReactionBuildingBlock(); _individualSimulation.SimulationSettings = new SimulationSettings(); A.CallTo(_containerTask).WithReturnType <PathCache <IQuantity> >().Returns(quantityCache); A.CallTo(() => _curveNamer.RenameCurvesWithOriginalNames(_individualSimulation, A <Action> ._, true)).Invokes(x => x.Arguments[1].DowncastTo <Action>()()); }
protected override void Context() { base.Context(); _newName = "TOTO"; _f1 = new ExplicitFormula("A+B"); _f2 = new ExplicitFormula("A+B"); _f3 = new ExplicitFormula("A+B"); _f1.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell")); _f1.AddObjectPath(new FormulaUsablePath("Drug", "LogP")); _f2.AddObjectPath(new FormulaUsablePath("SU", "Liver", "Cell")); _f2.AddObjectPath(new FormulaUsablePath("Drug", "LogP")); _f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "Liver", "Cell")); _f3.AddObjectPath(new FormulaUsablePath(_initialSimulationName, "LogP")); var p1 = new PKSimParameter().WithName("P1").WithFormula(_f1); var p2 = new PKSimParameter().WithName("P2").WithFormula(_f2); var p3 = new PKSimParameter().WithName("P3").WithFormula(_f3); var c1 = new Container().WithName("C1"); c1.Add(p3); _root.Add(p1); _root.Add(p2); _root.Add(c1); var results = new SimulationResults { Time = new QuantityValues { ColumnId = "0", QuantityPath = "baseGrid" } }; _individualResults = new IndividualResults { IndividualId = 1 }; results.Add(_individualResults); var quantityCache = new PathCacheForSpecs <IQuantity> { { "Liver|Cell|Drug", new MoleculeAmount { QuantityType = QuantityType.Drug } }, { "Liver|Cell|Meta", new MoleculeAmount { QuantityType = QuantityType.Metabolite } }, }; _individualResults.Add(new QuantityValues { PathList = new[] { "Liver", "Cell", "Drug" }.ToList() }); _individualResults.Add(new QuantityValues { PathList = new[] { "Liver", "Cell", "Meta" }.ToList() }); _individualSimulation.Results = results; A.CallTo(_containerTask).WithReturnType <PathCache <IQuantity> >().Returns(quantityCache); }
protected override void Context() { base.Context(); _formula = new ExplicitFormula(); _molecule = new MoleculeAmount(); _molecule.Add(new Parameter().WithName("k1")); _formula.AddObjectPath(new FormulaUsablePath(ObjectPath.PARENT_CONTAINER, "A")); _formula.AddObjectPath(new FormulaUsablePath("ORGANISM", "B")); _formula.AddObjectPath(new FormulaUsablePath("k1")); }
private IFormula createMucosaPermeabilityScaleFactor_transcellularFormula() { IFormula mucosaPermeabilityScaleFactor_transcellularFormula = _objectBaseFactory .Create <ExplicitFormula>() .WithFormulaString("P_int_trans_default >0 ? P_int_trans / P_int_trans_default : 0") .WithDimension(Constants.Dimension.NO_DIMENSION) .WithName("PARAM_P_int_scalefactor"); mucosaPermeabilityScaleFactor_transcellularFormula.AddObjectPath( createFormulaUsablePath(new[] { ObjectPath.PARENT_CONTAINER, "Default Intestinal permeability (transcellular)" }, "P_int_trans_default", _dimensionFactory.Dimension(AppConstants.DimensionNames.VELOCITY))); mucosaPermeabilityScaleFactor_transcellularFormula.AddObjectPath( createFormulaUsablePath(new[] { ObjectPath.PARENT_CONTAINER, "Intestinal permeability (transcellular)" }, "P_int_trans", _dimensionFactory.Dimension(AppConstants.DimensionNames.VELOCITY))); return(mucosaPermeabilityScaleFactor_transcellularFormula); }
protected override void Context() { _objectPathFactory = new ObjectPathFactory(new AliasCreator()); _buildConfiguration = A.Fake <IBuildConfiguration>(); _validFormula = new ExplicitFormula("5*PAR1"); _validFormula.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom("ROOT", "VALID", "PARA1").WithAlias("PAR1")); _invalidFormula = new ExplicitFormula("toto"); _invalidFormula.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom("ROOT", "INVALID", "PARA5").WithAlias("PAR1")); _rootContainer = new Container().WithName("ROOT"); _validContainer = new Container().WithName("VALID"); _validContainer.Add(new Parameter().WithName("PARA1").WithFormula(new ConstantFormula(1))); _validContainer.Add(new Parameter().WithName("PARA2").WithFormula(_validFormula)); _validContainer.Add(new Reaction().WithName("REACTION").WithFormula(_validFormula)); _validContainer.Add(new Transport().WithName("TRANSPORT").WithFormula(_validFormula)); _invalidContainer = new Container().WithName("INVALID"); _invalidContainer.Add(new Parameter().WithName("PARA1").WithFormula(new ConstantFormula(1))); _invalidContainer.Add(new Parameter().WithName("PARA2").WithFormula(_invalidFormula)); _invalidContainer.Add(new Reaction().WithName("REACTION").WithFormula(_invalidFormula)); _invalidContainer.Add(new Transport().WithName("TRANSPORT").WithFormula(_invalidFormula)); _rootContainer.Add(_validContainer); _rootContainer.Add(_invalidContainer); _objectTypeResolver = A.Fake <IObjectTypeResolver>(); }
protected override void Context() { base.Context(); _explicitFormula = new ExplicitFormula(); //another path _explicitFormula.AddObjectPath(new FormulaUsablePath(ObjectPath.PARENT_CONTAINER, ObjectPath.PARENT_CONTAINER, Constants.Parameters.VOLUME, Constants.Parameters.VOLUME).WithAlias(Constants.VOLUME_ALIAS)); }
public string AddParentVolumeReferenceToFormula(IFormula formula) { string volumeAlias = _aliasCreator.CreateAliasFrom(Constants.VOLUME_ALIAS, formula.ObjectPaths.Select(p => p.Alias)); //possible reference var volumeReferencePath = _objectPathFactory.CreateFormulaUsablePathFrom(ObjectPath.PARENT_CONTAINER, Constants.Parameters.VOLUME) .WithAlias(volumeAlias) .WithDimension(_dimensionFactory.Dimension(Constants.Dimension.VOLUME)); //do we have one already? var volumeReference = formula.ObjectPaths.FirstOrDefault(x => Equals(x.PathAsString, volumeReferencePath.PathAsString)); //was not defined yet if (volumeReference == null) { formula.AddObjectPath(volumeReferencePath); } else { volumeAlias = volumeReference.Alias; } //return the used alias return(volumeAlias); }
public void TestSerialization() { EventBuilder x1 = CreateObject <EventBuilder>().WithName("Eve.Builder").WithDimension(DimensionLength); x1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4); x1.OneTime = true; IFormula f1 = CreateObject <ExplicitFormula>().WithDimension(DimensionLength).WithFormulaString("3*Patty"); IFormulaUsablePath fup = new FormulaUsablePath(new string[] { "Patricia" }).WithAlias("Patty").WithDimension(DimensionLength); f1.AddObjectPath(fup); IFormula f2 = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4); IParameter p1 = WithExtensions.WithValue <Parameter>(CreateObject <Parameter>().WithName("Patricia").WithFormula(f1), 3.1); IParameter p2 = WithExtensions.WithValue <Parameter>(CreateObject <Parameter>().WithName("Pascal").WithFormula(f1), 3.2); x1.AddParameter(p1); x1.AddParameter(p2); IEventAssignmentBuilder eab1 = CreateObject <EventAssignmentBuilder>().WithDimension(DimensionLength).WithFormula(f1).WithName("eab1"); IEventAssignmentBuilder eab2 = CreateObject <EventAssignmentBuilder>().WithFormula(f2).WithName("eab2"); x1.AddAssignment(eab1); x1.AddAssignment(eab2); var x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualEventBuilder(x1, x2); }
/// <summary> /// Creates the blood2 plasma formula. /// </summary> private IFormula createBlood2PlasmaFormula() { IFormula blood2PlasmaFormula = _objectBaseFactory .Create <ExplicitFormula>() .WithFormulaString( "(f_water_rbc + f_lipids_rbc * 10 ^ LogP + f_proteins_rbc * KProt) * fu * HCT - HCT + 1") .WithDimension(Constants.Dimension.NO_DIMENSION) .WithName("PARAM_Blood2Plasma"); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { ObjectPathKeywords.MOLECULE, "Fraction unbound (plasma)" }, "fu", _dimensionFactory.Dimension(AppConstants.DimensionNames.FRACTION))); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { ObjectPathKeywords.MOLECULE, "Lipophilicity" }, "LogP", _dimensionFactory.Dimension("Log Units"))); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { ObjectPathKeywords.MOLECULE, "Partition coefficient (water/protein)" }, "KProt", Constants.Dimension.NO_DIMENSION)); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { "Organism", "Hematocrit" }, "HCT", Constants.Dimension.NO_DIMENSION)); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { "Organism", "Vf (lipid, blood cells)" }, "f_lipids_rbc", Constants.Dimension.NO_DIMENSION)); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { "Organism", "Vf (protein,blood cells)" }, "f_proteins_rbc", Constants.Dimension.NO_DIMENSION)); blood2PlasmaFormula.AddObjectPath( createFormulaUsablePath(new[] { "Organism", "Vf (water,blood cells)" }, "f_water_rbc", Constants.Dimension.NO_DIMENSION)); return(blood2PlasmaFormula); }
protected override void Context() { _formulaUsablePath = new FormulaUsablePath("path") { Alias = "alias" }; _formula = new ExplicitFormula(); _formula.AddObjectPath(_formulaUsablePath); sut = new FormulaUsablePathDTO(_formulaUsablePath, _formula); }
protected override void Context() { _formula = new ExplicitFormula("A+B").WithId("id"); _buildingBlock = A.Fake <IBuildingBlock>(); _context = A.Fake <IMoBiContext>(); _newObjectPath = new FormulaUsablePath("NEW", "PATH").WithAlias("C1"); _oldObjectPath = new FormulaUsablePath("OLD", "PATH").WithAlias("C1"); sut = new EditPathAtUsablePathCommand(_formula, _newObjectPath, _oldObjectPath, _buildingBlock); _formula.AddObjectPath(_oldObjectPath); A.CallTo(() => _context.Get <IFormula>(_formula.Id)).Returns(_formula); _buildingBlockVersionUpdater = A.Fake <IBuildingBlockVersionUpdater>(); A.CallTo(() => _context.Resolve <IBuildingBlockVersionUpdater>()).Returns(_buildingBlockVersionUpdater); }
protected override void Context() { base.Context(); _buildConfiguration = A.Fake <IBuildConfiguration>(); _processBuilder = new ReactionBuilder(); _processBuilder.CreateProcessRateParameter = true; _kinetic = new ExplicitFormula("(A+B)*fu/BW"); _formulaUsablePathA = new FormulaUsablePath(new[] { ObjectPath.PARENT_CONTAINER, "A" }).WithAlias("A"); _kinetic.AddObjectPath(_formulaUsablePathA); _formulaUsablePathB = new FormulaUsablePath(new[] { "B" }).WithAlias("B"); _kinetic.AddObjectPath(_formulaUsablePathB); _formulaUsablePathFU = new FormulaUsablePath(new[] { ObjectPathKeywords.MOLECULE, "fu" }).WithAlias("fu"); _kinetic.AddObjectPath(_formulaUsablePathFU); _formulaUsablePathBW = new FormulaUsablePath(new[] { "Organism", "BW" }).WithAlias("BW"); _kinetic.AddObjectPath(_formulaUsablePathBW); _processBuilder.CreateProcessRateParameter = true; _processBuilder.ProcessRateParameterPersistable = true; A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _buildConfiguration)).Returns(_kinetic); _processBuilder.Name = "Reaction"; _processBuilder.Formula = _kinetic; _processRateParameter = new Parameter(); A.CallTo(() => _objectBaseFactory.Create <IParameter>()).Returns(_processRateParameter); }
private IFormula creteDefaultIntestinalPermeabilityTranscellularFormula() { var velocity = _dimensionFactory.Dimension(AppConstants.DimensionNames.VELOCITY); IFormula defaultIntestinalPermeabilityTranscellularFormula = _objectBaseFactory .Create <ExplicitFormula>() .WithFormulaString("P_int_InVitro") .WithDimension(velocity) .WithName("PARAM_P_int_trans_default"); defaultIntestinalPermeabilityTranscellularFormula.AddObjectPath( createFormulaUsablePath(new string[] { ObjectPath.PARENT_CONTAINER, "Calculated specific intestinal permeability (transcellular)" }, "P_int_InVitro", velocity) ); return(defaultIntestinalPermeabilityTranscellularFormula); }
public void TestSerialization() { MoleculeBuilder x1 = CreateObject <MoleculeBuilder>().WithName("Monica.Builder"); x1.IsFloating = true; x1.QuantityType = QuantityType.Metabolite; x1.DefaultStartFormula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4); TransportBuilder t1 = CreateObject <TransportBuilder>().WithName("Passive Transport"); IFormula consFormula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(5); IParameter transporterParameter = CreateObject <Parameter>().WithName("Passive Transport Param").WithFormula(consFormula).WithMode(ParameterBuildMode.Property) .WithDimension(DimensionLength); t1.AddParameter(transporterParameter); IFormula f1 = CreateObject <ExplicitFormula>().WithDimension(DimensionLength).WithFormulaString("3*Patty"); IFormulaUsablePath fup = new FormulaUsablePath(new[] { "Patricia" }).WithAlias("Patty").WithDimension(DimensionLength); f1.AddObjectPath(fup); IParameter p1 = CreateObject <Parameter>().WithName("Patricia").WithFormula(f1).WithValue(3.1).WithMode(ParameterBuildMode.Property); IParameter p2 = CreateObject <Parameter>().WithName("Pascal").WithFormula(f1).WithValue(3.2).WithMode(ParameterBuildMode.Local); IParameter p3 = CreateObject <Parameter>().WithName("Paul").WithFormula(f1).WithValue(3.3); x1.AddParameter(p1); x1.AddParameter(p2); var atbc1 = CreateObject <TransporterMoleculeContainer>().WithName("Tranquilo"); ITransportBuilder atb1 = CreateObject <TransportBuilder>(); atb1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(2.5); atb1.AddParameter(p3); atb1.Name = "Tranquilo"; atbc1.AddActiveTransportRealization(atb1); var atbc2 = CreateObject <TransporterMoleculeContainer>().WithName("Tranquilo2"); ITransportBuilder atb2 = CreateObject <TransportBuilder>(); atb2.Formula = f1; atb2.Name = "Tranquilo2"; atbc2.AddActiveTransportRealization(atb2); x1.AddTransporterMoleculeContainer(atbc1); x1.AddTransporterMoleculeContainer(atbc2); x1.IsXenobiotic = !x1.IsXenobiotic; var interactionContainer = CreateObject <InteractionContainer>().WithName("Interactions"); x1.AddInteractionContainer(interactionContainer); var x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualMoleculeBuilder(x1, x2); }
protected override void Context() { base.Context(); _formula = new ExplicitFormula(); _formula.Name = _changedName; _path = new FormulaUsablePath(new[] { "A", "B", _changedName }) { Alias = _changedName }; A.CallTo(() => _aliasCreator.CreateAliasFrom(_changedName)).Returns(_changedName); A.CallTo(() => _aliasCreator.CreateAliasFrom(_newName)).Returns(_newName); _formula.AddObjectPath(_path); _moleculeBuildingBlock = new MoleculeBuildingBlock().WithName("M").WithId("M"); _moleculeBuildingBlock.AddFormula(_formula); }
protected override void Context() { _buildingBlock = A.Fake <IBuildingBlock>(); _alias = "alias"; _formula = new ExplicitFormula("string"); _formula.AddObjectPath(new FormulaUsablePath { Alias = _alias, Dimension = DomainHelperForSpecs.AmountDimension }); _newDimension = DomainHelperForSpecs.ConcentrationDimension; _context = A.Fake <IMoBiContext>(); A.CallTo(() => _context.Get <IFormula>(_formula.Id)).Returns(_formula); A.CallTo(() => _context.DimensionFactory.Dimension(_newDimension.ToString())).Returns(_newDimension); A.CallTo(() => _context.DimensionFactory.Dimension(DomainHelperForSpecs.AmountDimension.ToString())).Returns(DomainHelperForSpecs.AmountDimension); sut = new UpdateDimensionOfFormulaUsablePathCommand(_newDimension, _formula, _alias, _buildingBlock); }
public void TestSerialization() { IFormula f1 = CreateObject <ConstantFormula>().WithName("F.Constantin").WithDimension(DimensionLength).WithValue(2.1); IFormula f2 = CreateObject <ExplicitFormula>().WithName("F.Erika").WithDimension(DimensionLength).WithFormulaString("A * 2"); IFormulaUsablePath fup = new FormulaUsablePath(new[] { "aa", "bb" }).WithAlias("b").WithDimension(DimensionLength); f2.AddObjectPath(fup); FormulaCache x1 = new FormulaCache(); x1.Add(f1); x1.Add(f2); IFormulaCache x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualFormulaCache(x2, x1); }
public void TestSerializationParameterBuilderWithParameterWithExplicitFormula() { IFormula f1 = CreateObject <ExplicitFormula>().WithDimension(DimensionLength).WithFormulaString("3*Patty"); Parameter x1 = CreateObject <Parameter>().WithName("Peter").WithFormula(f1); x1.BuildMode = ParameterBuildMode.Local; IFormulaUsablePath fup = new FormulaUsablePath(new[] { "Patricia" }).WithAlias("Patty").WithDimension(DimensionLength); f1.AddObjectPath(fup); x1.Value = 3.4; IParameter x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualParameterBuilder(x2, x1); }
public void TestSerialization() { TransportBuilder x1 = CreateObject <TransportBuilder>().WithName("Priscilla.Builder").WithDimension(DimensionLength); x1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4); x1.CreateProcessRateParameter = true; IFormula f1 = CreateObject <ExplicitFormula>().WithDimension(DimensionLength).WithFormulaString("3*Patty"); IFormulaUsablePath fup = new FormulaUsablePath(new[] { "Patricia" }).WithAlias("Patty").WithDimension(DimensionLength); f1.AddObjectPath(fup); //WithValue to avoid formula evaluation in McAssertForSpecs-comparison. IParameter p1 = CreateObject <Parameter>().WithName("Patricia").WithFormula(f1).WithValue(3.1); IParameter p2 = CreateObject <Parameter>().WithName("Pascal").WithFormula(f1).WithValue(3.2); x1.AddParameter(p1); x1.AddParameter(p2); ITransportBuilder x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualProcessBuilder(x1, x2); }