private void updateParameterValueFromParameterStartValues(IModel model, IBuildConfiguration buildConfiguration)
{
foreach (var parameterStartValue in buildConfiguration.ParameterStartValues)
{
var pathInModel = _keywordReplacerTask.CreateModelPathFor(parameterStartValue.Path, model.Root);
var parameter = pathInModel.Resolve <IParameter>(model.Root);
//this can happen if the parameter belongs to a molecule locale properties and the molecule was not created in the container
if (parameter == null)
{
continue;
}
if (parameterStartValue.Formula != null)
{
parameter.Formula = _cloneManagerForModel.Clone(parameterStartValue.Formula);
_keywordReplacerTask.ReplaceIn(parameter, model.Root);
}
else
{
var constantFormula = parameter.Formula as ConstantFormula;
var parameterValue = parameterStartValue.StartValue.GetValueOrDefault(double.NaN);
if (constantFormula == null)
{
if (parameterStartValue.OverrideFormulaWithValue)
{
parameter.Formula = _formulaFactory.ConstantFormula(parameterValue, parameter.Dimension);
}
else
{
parameter.Value = parameterValue;
}
}
else
{
constantFormula.Value = parameterValue;
}
}
//Ensure that parameter in simulation appears no to have been fixed by the user when updated from PSV
if (parameterStartValue.OverrideFormulaWithValue)
{
parameter.IsFixedValue = false;
}
}
}
public IParameter CreateParameter(string name, double?value = null, IDimension dimension = null, string groupName = null, IFormula formula = null, Unit displayUnit = null)
{
var dimensionToUse = dimension ?? _dimensionFactory.NoDimension;
var displayUnitToUse = displayUnit ?? _displayUnitRetriever.PreferredUnitFor(dimensionToUse);
var formulaToUse = formula ?? _formulaFactory.ConstantFormula(value.GetValueOrDefault(double.NaN), dimensionToUse);
return(_objectBaseFactory.Create <IParameter>()
.WithName(name)
.WithDimension(dimensionToUse)
.WithFormula(formulaToUse)
.WithDisplayUnit(displayUnitToUse)
.WithGroup(groupName ?? Constants.Groups.MOBI));
}
protected override void Context()
{
_reactionDimensionRetriever = A.Fake <IReactionDimensionRetriever>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_amoutToConcentrationFormulaMapper = A.Fake <IAmoutToConcentrationFormulaMapper>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_formulaTask = A.Fake <IFormulaTask>();
_displayUnitRetriever = A.Fake <IDisplayUnitRetriever>();
_formulaFactory = A.Fake <IFormulaFactory>();
_constantZeroFormula = new ConstantFormula(0);
_formulaCache = new FormulaCache();
_objectTypeResolver = new ObjectTypeResolver();
A.CallTo(() => _formulaTask.AddParentVolumeReferenceToFormula(A <IFormula> ._)).Returns(Constants.VOLUME_ALIAS);
A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.AMOUNT)).Returns(DomainHelperForSpecs.AmountDimension);
A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.AMOUNT_PER_TIME)).Returns(DomainHelperForSpecs.AmountPerTimeDimension);
A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.MOLAR_CONCENTRATION)).Returns(DomainHelperForSpecs.ConcentrationDimension);
A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.MOLAR_CONCENTRATION_PER_TIME)).Returns(DomainHelperForSpecs.ConcentrationPerTimeDimension);
A.CallTo(() => _objectBaseFactory.Create <ExplicitFormula>()).Returns(new ExplicitFormula());
A.CallTo(() => _formulaFactory.ConstantFormula(0, DomainHelperForSpecs.ConcentrationDimension)).Returns(_constantZeroFormula);
sut = new AmountToConcentrationConverter(_reactionDimensionRetriever, _dimensionFactory, _amoutToConcentrationFormulaMapper,
_objectBaseFactory, _formulaTask, _displayUnitRetriever, _objectTypeResolver, _formulaFactory);
}
/// <summary>
/// Creates a MoBi Parameter from a given SBML Parameter.
/// </summary>
public IFormulaUsable CreateParameter(Parameter sbmlParameter)
{
var value = 0.0;
if (sbmlParameter.isSetValue())
{
value = sbmlParameter.getValue();
}
if (!sbmlParameter.isSetUnits())
{
return(ObjectBaseFactory.Create <IParameter>()
.WithName(sbmlParameter.getId())
.WithFormula(ObjectBaseFactory.Create <ConstantFormula>().WithValue(value)));
}
var sbmlUnit = sbmlParameter.getUnits();
var baseValue = _unitDefinitionImporter.ToMobiBaseUnit(sbmlUnit, value);
return(ObjectBaseFactory.Create <IParameter>()
.WithName(sbmlParameter.getId())
.WithFormula(_formulaFactory.ConstantFormula(baseValue.value, baseValue.dimension))
.WithDimension(baseValue.dimension));
}
/// <summary>
/// Creates a Volume Parameter for a MoBi Container.
/// </summary>
private IEntity CreateVolumeParameter(Compartment compartment)
{
var volume = 1.0;
if (compartment.isSetVolume())
{
volume = compartment.getVolume();
}
else if (compartment.isSetSize())
{
volume = compartment.getSize();
}
var unit = compartment.getUnits();
var baseValue = _unitDefinitionImporter.ToMobiBaseUnit(unit, volume);
IFormula formula = _formulaFactory.ConstantFormula(baseValue.value, baseValue.dimension);
var volumeParameter = _objectBaseFactory.Create <IParameter>()
.WithName(SBMLConstants.VOLUME)
.WithDimension(baseValue.dimension)
.WithFormula(formula);
return(volumeParameter);
}
private IFormula createConstantConcentrationFormula(double value)
{
return(_formulaFactory.ConstantFormula(value, _concentrationDimension));
}
