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);
}