public void should_retrieve_some_object_from_the_underlying_database()
{
_result.Count().ShouldBeGreaterThan(0);
ParameterRateMetaData firstElement = _result.ElementAt(0);
firstElement.Rate.ShouldNotBeNull();
firstElement.CalculationMethod.ShouldNotBeNull();
}
private ParameterRateMetaData rateParam(string paramName, string rate)
{
var parameterMetaData = _parameterRateRepository.ParameterMetaDataFor(_containerPath, paramName);
var parameterRateMetaData = new ParameterRateMetaData();
parameterRateMetaData.UpdatePropertiesFrom(parameterMetaData);
parameterRateMetaData.Rate = rate;
return(parameterRateMetaData);
}
protected override void Context()
{
base.Context();
_rateDefinition = new ParameterRateMetaData {
Rate = "toto", CalculationMethod = "tutu"
};
A.CallTo(() => _rateObjectPathsRepository.ObjectPathsFor(new RateKey(_rateDefinition.CalculationMethod, _rateDefinition.Rate))).Returns(new List <IFormulaUsablePath>());
A.CallTo(() => _rateFormulaRepository.FormulaFor(new RateKey(_rateDefinition.CalculationMethod, _rateDefinition.Rate))).Returns("0");
A.CallTo(() => _idGenerator.NewId()).Returns("newId");
}
protected override void Context()
{
base.Context();
_formulaCache = A.Fake <IFormulaCache>();
_parameterRateDefinition = new ParameterRateMetaData();
_parameterRateDefinition.ParameterName = "Tralal";
_rateFormula = A.Fake <IFormula>();
_parameter = A.Fake <IParameter>();
A.CallTo(() => _formulaFactory.RateFor(_parameterRateDefinition, _formulaCache)).Returns(_rateFormula);
A.CallTo(() => _objectBaseFactory.CreateParameter()).Returns(_parameter);
A.CallTo(() => _dimensionRepository.DimensionByName(_parameterRateDefinition.Dimension)).Returns(_dimension);
}
protected override void Context()
{
base.Context();
_rateDefinition = new ParameterRateMetaData {
Rate = "toto", CalculationMethod = "tutu"
};
var rateKey = new RateKey(_rateDefinition.CalculationMethod, _rateDefinition.Rate);
A.CallTo(() => _rateObjectPathsRepository.ObjectPathsFor(rateKey)).Returns(Enumerable.Empty <IFormulaUsablePath>());
_formulaString = "10";
A.CallTo(() => _rateFormulaRepository.FormulaFor(rateKey)).Returns(_formulaString);
}
public ICoreCalculationMethod MapFrom(string calculationMethod)
{
var modelCalcMethod = new CoreCalculationMethod {
Name = calculationMethod
};
modelCalcMethod.Category = _calculationMethodRepository.FindBy(calculationMethod).Category;
var allRates = from cmr in _flatCalculationMethodParameterRateRepository.All()
where cmr.CalculationMethod.Equals(calculationMethod)
select cmr;
foreach (var parameterRate in allRates)
{
var descriptor = descriptorCriteriaFrom(parameterRate.ParameterId);
if (parameterRate.IsOutputParameter)
{
var paramDescriptor = new ParameterDescriptor(parameterRate.ParameterName, descriptor);
modelCalcMethod.AddOutputFormula(_formulaFactory.RateFor(parameterRate.CalculationMethod, parameterRate.Rate, new FormulaCache()), paramDescriptor);
}
else
{
var parameterRateMetaData = new ParameterRateMetaData
{
BuildingBlockType = PKSimBuildingBlockType.Simulation,
BuildMode = ParameterBuildMode.Local,
CalculationMethod = parameterRate.CalculationMethod,
CanBeVaried = parameterRate.CanBeVaried,
CanBeVariedInPopulation = parameterRate.CanBeVariedInPopulation,
Dimension = parameterRate.Dimension,
GroupName = parameterRate.GroupName,
ReadOnly = parameterRate.ReadOnly,
MinValue = parameterRate.MinValue,
MaxValue = parameterRate.MaxValue,
MinIsAllowed = parameterRate.MinIsAllowed,
MaxIsAllowed = parameterRate.MaxIsAllowed,
ParameterName = parameterRate.ParameterName,
Rate = parameterRate.Rate,
Visible = parameterRate.Visible,
Sequence = parameterRate.Sequence
};
var helpParameter = _parameterFactory.CreateFor(parameterRateMetaData, new FormulaCache());
modelCalcMethod.AddHelpParameter(helpParameter, descriptor);
}
}
return(modelCalcMethod);
}
protected override void Context()
{
_parameterQuery = A.Fake <IParameterQuery>();
_parameterFactory = A.Fake <IParameterFactory>();
_originData = new OriginData();
_param1 = A.Fake <IParameter>();
_param1.Name = "param1";
var paramDef1 = new ParameterValueMetaData
{
BuildingBlockType = PKSimBuildingBlockType.Individual
};
_param2 = A.Fake <IParameter>();
_param2.Name = "param2";
var paramDef2 = new ParameterValueMetaData
{
BuildingBlockType = PKSimBuildingBlockType.Individual
};
_param3 = A.Fake <IParameter>();
_param3.Name = "param3";
var paramDef3 = new ParameterValueMetaData
{
BuildingBlockType = PKSimBuildingBlockType.Compound
};
_valueDefinitions.Add(paramDef1);
_valueDefinitions.Add(paramDef2);
var paramRateDef1 = new ParameterRateMetaData();
paramDef3.BuildingBlockType = PKSimBuildingBlockType.Individual;
_rateDefinitions.Add(paramRateDef1);
_paramRate1 = new PKSimParameter().WithFormula(new ExplicitFormula("a formula"));
_paramRate1.Name = "RateParameter";
A.CallTo(_parameterQuery).WithReturnType <IEnumerable <ParameterValueMetaData> >().Returns(_valueDefinitions);
A.CallTo(_parameterQuery).WithReturnType <IEnumerable <ParameterDistributionMetaData> >().Returns(_distributionDefinitions);
A.CallTo(_parameterQuery).WithReturnType <IEnumerable <ParameterRateMetaData> >().Returns(_rateDefinitions);
A.CallTo(() => _parameterFactory.CreateFor(paramDef1)).Returns(_param1);
A.CallTo(() => _parameterFactory.CreateFor(paramDef2)).Returns(_param2);
A.CallTo(() => _parameterFactory.CreateFor(paramRateDef1, A <FormulaCache> ._)).Returns(_paramRate1);
sut = new ParameterContainerTask(_parameterQuery, _parameterFactory);
}
private bool isChangedFlowParameter(ParameterRateMetaData parameterRateMetaData,
string flowParameterName,
string flowInclMucosaParameterName)
{
if (parameterRateMetaData.ContainerType != CoreConstants.ContainerType.ORGAN)
{
return(false);
}
var container = parameterRateMetaData.ContainerName;
if (container.Equals(ENDOGENOUS_IGG) ||
container.Equals(PORTAL_VEIN))
{
return(false);
}
var name = parameterRateMetaData.ParameterName;
var isIntestine = container.IsOneOf(LARGE_INTESTINE, SMALL_INTESTINE);
return((name.Equals(flowParameterName) && !isIntestine) ||
(name.Equals(flowInclMucosaParameterName) && isIntestine));
}
private bool isChangedFlowParameter(ParameterRateMetaData parameterRateMetaData,
string flowParameterName,
string flowInclMucosaParameterName)
{
if (parameterRateMetaData.ContainerType != CoreConstants.ContainerType.Organ)
{
return(false);
}
var container = parameterRateMetaData.ContainerName;
if (container.Equals(CoreConstants.Organ.EndogenousIgG) ||
container.Equals(CoreConstants.Organ.PortalVein))
{
return(false);
}
var name = parameterRateMetaData.ParameterName;
var isIntestine = container.IsOneOf(CoreConstants.Organ.LargeIntestine, CoreConstants.Organ.SmallIntestine);
return((name.Equals(flowParameterName) && !isIntestine) ||
(name.Equals(flowInclMucosaParameterName) && isIntestine));
}
protected IParameter CreateFormulaParameterIn(
IContainer parameterContainer,
ParameterRateMetaData parameterRateMetaData,
string moleculeName,
string groupName = null)
{
var parameter = _parameterFactory.CreateFor(parameterRateMetaData, new FormulaCache());
parameterContainer.Add(parameter);
if (!string.IsNullOrEmpty(groupName))
{
parameter.GroupName = groupName;
}
//Because we update the formula of the parameter, we need to make sure we also reset the formulaId so that it will appear as being unique
parameter.Formula.ReplaceKeywordsInObjectPaths(new[] { ObjectPathKeywords.MOLECULE }, new[] { moleculeName });
parameter.Formula.Id = _idGenerator.NewId();
//All constant parameters do not have default values
parameter.DefaultValue = null;
return(parameter);
}
protected override void Context()
{
_compartment = A.Fake <Compartment>();
A.CallTo(() => _compartment.OrganName).Returns("MyParentOrgan");
_compartment.Name = "MyComp";
var containerPath = new ObjectPath(new[] { _compartment.OrganName, _compartment.Name }).ToString();
_containerPathRetriever = A.Fake <IEntityPathResolver>();
A.CallTo(() => _containerPathRetriever.PathFor(_compartment)).Returns(containerPath);
_originData = new OriginData();
_originData.Population = new SpeciesPopulation();
var distributionDefinition = new ParameterDistributionMetaData();
var rateDefinition = new ParameterRateMetaData();
var valueDefinition = new ParameterValueMetaData();
distributionDefinition.ParameterName = "tutu";
var distributionRepository = A.Fake <IParameterDistributionRepository>();
A.CallTo(() => distributionRepository.AllFor(containerPath)).Returns(new List <ParameterDistributionMetaData> {
distributionDefinition
});
var rateRepository = A.Fake <IParameterRateRepository>();
A.CallTo(() => rateRepository.AllFor(containerPath)).Returns(new List <ParameterRateMetaData> {
rateDefinition
});
var valueRepository = A.Fake <IParameterValueRepository>();
A.CallTo(() => valueRepository.AllFor(containerPath)).Returns(new List <ParameterValueMetaData> {
valueDefinition
});
sut = new ParameterQuery(distributionRepository, valueRepository, rateRepository, _containerPathRetriever);
}
private bool isChangedLymphFlowParameter(ParameterRateMetaData parameterRateMetaData)
{
return(isChangedFlowParameter(parameterRateMetaData,
CoreConstants.Parameters.LYMPH_FLOW,
CoreConstants.Parameters.LYMPH_FLOW_INCL_MUCOSA));
}
private bool isChangedFluidRecircFlowParameter(ParameterRateMetaData parameterRateMetaData)
{
return(isChangedFlowParameter(parameterRateMetaData,
CoreConstants.Parameters.RECIRCULATION_FLOW,
CoreConstants.Parameters.RECIRCULATION_FLOW_INCL_MUCOSA));
}
