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 selectFormulaByTypeAndName(Type formulaType, string formulaName)
{
var newFormula = needsName(formulaType)
? getFormulaFromFormulaCache(formulaType, formulaName)
: getConstantFormula();
//only the first time that a new formula is created from an empty formula cache
if (newFormula == null)
{
_formula = _formulaTask.CreateNewFormula(formulaType, formulaDimension);
}
else
{
selectFormula(newFormula);
}
}
protected override void Context()
{
_simulation = new MoBiSimulation();
_buildingBlock = new MoleculeBuildingBlock();
_formulaParameter = new Parameter().WithFormula(new ExplicitFormula()).WithName("formula");
_formulaParameter.Value = 9;
_constantParameter = new Parameter().WithFormula(new ConstantFormula(1.0)).WithName("constant");
_unaffectedParameter = new Parameter().WithFormula(new ConstantFormula(1.0)).WithName("unaffected");
_unaffectedParameter.Value = 5.0;
_constantParameter.Value = 9;
_simulation.Model = new Model {
Root = new Container {
_formulaParameter, _constantParameter, _unaffectedParameter
}
};
_context = A.Fake <IMoBiContext>();
sut = new ResetFixedConstantParametersToDefaultInSimulationCommand <MoleculeBuildingBlock>(_simulation, _buildingBlock);
_affectedBuildingBlockRetriever = A.Fake <IAffectedBuildingBlockRetriever>();
_formulaTask = A.Fake <IMoBiFormulaTask>();
A.CallTo(() => _formulaTask.CreateNewFormula <ConstantFormula>(A <IDimension> ._)).Returns(new ConstantFormula());
A.CallTo(() => _context.Resolve <IAffectedBuildingBlockRetriever>()).Returns(_affectedBuildingBlockRetriever);
A.CallTo(() => _context.Resolve <IMoBiFormulaTask>()).Returns(_formulaTask);
var buildingBlockInfo = new MoleculesInfo {
BuildingBlock = _buildingBlock
};
A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(_constantParameter, _simulation)).Returns(buildingBlockInfo);
A.CallTo(() => _affectedBuildingBlockRetriever.RetrieveFor(_formulaParameter, _simulation)).Returns(buildingBlockInfo);
}
private IFormula defaultFormulaBasedOn(IStartValue startValue)
{
if (startValue.Formula != null)
{
return(_cloneManagerForModel.Clone(startValue.Formula));
}
return(_formulaTask.CreateNewFormula <ConstantFormula>(startValue.Dimension).WithValue(startValue.StartValue.GetValueOrDefault(double.NaN)));
}
public override IParameter CreateNewEntity(IContainer parent)
{
var parameter = base.CreateNewEntity(parent)
.WithParentContainer(parent)
.WithDimension(_dimensionFactory.TryGetDimension(_interactionTaskContext.UserSettings.ParameterDefaultDimension))
.WithMode(parent.DefaultParameterBuildMode())
.WithGroup(Constants.Groups.MOBI);
parameter.Formula = _formulaTask.CreateNewFormula <ConstantFormula>(parameter.Dimension);
parameter.DisplayUnit = _interactionTaskContext.DisplayUnitFor(parameter);
parameter.Visible = true;
return(parameter);
}
protected IMoBiCommand AddFormulaToFormulaCacheAndSetOnStartValue <TFormula>(TBuildingBlock startValuesBuildingBlock, TStartValue startValue, IParameter referenceParameter)
where TFormula : IFormula
{
var macroCommand = new MoBiMacroCommand
{
CommandType = AppConstants.Commands.AddCommand,
Description = AppConstants.Commands.AddFormulaToBuildingBlock,
ObjectType = _interactionTaskContext.GetTypeFor <TFormula>()
};
var newFormula = _moBiFormulaTask.CreateNewFormula <TFormula>(startValue.Dimension);
macroCommand.AddCommand(new AddFormulaToFormulaCacheCommand(startValuesBuildingBlock, newFormula).Run(Context));
if (!_moBiFormulaTask.EditNewFormula(newFormula, macroCommand, startValuesBuildingBlock, referenceParameter))
{
return(CancelCommand(macroCommand));
}
macroCommand.Add(SetFormula(startValuesBuildingBlock, startValue, newFormula));
return(macroCommand);
}
private void setDefaultStartFormula(IMoleculeBuilder moleculeBuilder)
{
moleculeBuilder.DefaultStartFormula = _formulaTask.CreateNewFormula <ConstantFormula>(_dimensionRetriever.MoleculeDimension);
}
private void resetQuantity(IQuantity quantity)
{
quantity.Formula = _formulaTask.CreateNewFormula <ConstantFormula>(quantity.Dimension).WithValue(quantity.Value);
quantity.IsFixedValue = false;
}
