protected override void Context()
{
_parameterMapper = A.Fake <IParameterToParameterDTOMapper>();
_subPopulationDTOMapper = A.Fake <ISubPopulationToSubPopulationDTOMapper>();
_calculationMethodDTOMapper = A.Fake <ICalculationMethodToCategoryCalculationMethodDTOMapper>();
_species = new Species {
Name = "species"
};
_speciesPopulation = new SpeciesPopulation {
Name = "population"
};
_speciesPopulation.AddGender(new Gender {
Name = "gender"
});
_species.AddPopulation(_speciesPopulation);
sut = new IndividualToIIndividualSettingsDTOMapper(_parameterMapper, _subPopulationDTOMapper, _calculationMethodDTOMapper);
}
public Individual DefaultIndividualFor(SpeciesPopulation speciesPopulation)
{
if (!_individualCacheProSpecies.Contains(speciesPopulation))
{
var originDataSnapshot = new OriginData
{
Species = speciesPopulation.Species,
Population = speciesPopulation.Name,
Gender = DefaultGenderFor(speciesPopulation).Name
};
//We do not need to pass any valid snapshot context in this case.
var originData = _originDataMapper.MapToModel(originDataSnapshot, new SnapshotContext()).Result;
_individualCacheProSpecies[speciesPopulation] = _individualFactory.CreateStandardFor(originData);
}
return(_individualCacheProSpecies[speciesPopulation]);
}
protected override void Context()
{
base.Context();
_species = A.Fake <Species>();
_defaultPopulation = new SpeciesPopulation().WithName("POP");
A.CallTo(() => _species.DefaultPopulation).Returns(_defaultPopulation);
var individualSettingsDTO = new IndividualSettingsDTO();
A.CallTo(() => _individualDefaultValueRetriever.DefaultSettingFor(_defaultPopulation)).Returns(individualSettingsDTO);
var originData = new OriginData();
A.CallTo(() => _insividualSettingsMapper.MapFrom(individualSettingsDTO)).Returns(originData);
_individual = new Individual();
A.CallTo(() => _individualFactory.CreateStandardFor(originData)).Returns(_individual);
}
protected override void Context()
{
_speciesRepository = A.Fake <ISpeciesRepository>();
_view = A.Fake <IIndividualSettingsView>();
_defaultValueUpdater = A.Fake <IIndividualDefaultValueUpdater>();
_individualSettingsDTOMapper = A.Fake <IIndividualToIIndividualSettingsDTOMapper>();
_individualMapper = A.Fake <IIndividualSettingsDTOToIndividualMapper>();
_calculationMethodRepository = A.Fake <ICalculationMethodCategoryRepository>();
_subPopulation = A.Fake <IEnumerable <CategoryParameterValueVersionDTO> >();
_editValueOriginPresenter = A.Fake <IEditValueOriginPresenter>();
_defaultIndividualRetriever = A.Fake <IDefaultIndividualRetriever>();
_diseaseStateRepository = A.Fake <IDiseaseStateRepository>();
_individualSettingsDTO = new IndividualSettingsDTO();
_individualPropertiesDTO = new ObjectBaseDTO();
_speciesPopulation = A.Fake <SpeciesPopulation>();
_species = A.Fake <Species>();
_gender = A.Fake <Gender>();
_cmCat1 = new CalculationMethodCategory();
_cmCat2 = new CalculationMethodCategory();
_cmCat1.Add(new CalculationMethod());
_cmCat2.Add(new CalculationMethod());
_individualSettingsDTO.Species = _species;
_individualSettingsDTO.Population = _speciesPopulation;
_individualSettingsDTO.Gender = _gender;
A.CallTo(() => _defaultIndividualRetriever.DefaultIndividual()).Returns(_defaultIndividual);
A.CallTo(() => _individualSettingsDTOMapper.MapFrom(_defaultIndividual)).Returns(_individualSettingsDTO);
A.CallTo(() => _calculationMethodRepository.All()).Returns(new[] { _cmCat1, _cmCat2 });
_individualSettingsDTO.SubPopulation = _subPopulation;
_parentPresenter = A.Fake <IIndividualPresenter>();
sut = new IndividualSettingsPresenter(
_view,
_speciesRepository,
_calculationMethodRepository,
_defaultIndividualRetriever,
_defaultValueUpdater,
_individualSettingsDTOMapper,
_individualMapper,
_editValueOriginPresenter,
_diseaseStateRepository);
sut.InitializeWith(_parentPresenter);
}
public IReadOnlyList <IContainer> SubContainersFor(SpeciesPopulation population, ModelConfiguration modelConfiguration, IContainer parentContainer)
{
var allSubContainers = new List <IContainer>();
string pathToParentContainer = _entityPathResolver.PathFor(parentContainer);
var flatParentContainer = _flatContainerRepo.ContainerFrom(pathToParentContainer);
var flatModelSubContainers = _modelContainerRepo.AllSubContainerFor(modelConfiguration.ModelName, flatParentContainer.Id);
var allSpeciesSubContainer = populationSubContainers(population, flatParentContainer);
foreach (var flatModelContainer in flatModelSubContainers)
{
// check if container available in species
if (allSpeciesSubContainer.Contains(flatModelContainer.Id))
{
//model subcontainer available in the species structure - add to model subcontainers and continue
allSubContainers.Add(_flatContainerIdToContainerMapper.MapFrom(flatModelContainer));
continue;
}
// model subcontainer NOT available in species structure.
// In this case, action depends on UsageInIndividuum-flag
if (flatModelContainer.UsageInIndividual == CoreConstants.ORM.USAGE_IN_INDIVIDUAL_REQUIRED)
{
throw new ArgumentException(PKSimConstants.Error.ModelContainerNotAvailable(_flatContainerRepo.ContainerPathFrom(flatModelContainer.Id).ToString()));
}
if (flatModelContainer.UsageInIndividual == CoreConstants.ORM.USAGE_IN_INDIVIDUAL_OPTIONAL)
{
continue;
}
if (flatModelContainer.UsageInIndividual == CoreConstants.ORM.USAGE_IN_INDIVIDUAL_EXTENDED)
{
allSubContainers.Add(_flatContainerIdToContainerMapper.MapFrom(flatModelContainer));
continue;
}
throw new ArgumentException(PKSimConstants.Error.UnknownUsageInIndividualFlag(flatModelContainer.UsageInIndividual));
}
return(allSubContainers);
}
public SpeciesPopulation MapFrom(FlatPopulation flatPopulation)
{
var population = new SpeciesPopulation
{
Species = flatPopulation.Species,
IsAgeDependent = flatPopulation.IsAgeDependent,
IsHeightDependent = flatPopulation.IsHeightDependent,
Name = flatPopulation.Id,
RaceIndex = flatPopulation.RaceIndex,
Sequence = flatPopulation.Sequence,
};
foreach (var popGender in _populationGenderRepository.All().Where(item => item.Population == population.Name).OrderBy(x => x.Sequence))
{
population.AddGender(_genderRepository.FindByName(popGender.GenderName));
}
return(population);
}
protected override void Context()
{
base.Context();
_male = new Gender();
_american = new SpeciesPopulation();
_constantParameter = new PKSimParameter().WithName("P1").WithFormula(new ConstantFormula(1));
_formulaParameter1 = new PKSimParameter().WithName("P2").WithFormula(new ExplicitFormula("1+1"));
_formulaParameter2 = new PKSimParameter().WithName("P3").WithFormula(new ExplicitFormula("1+2"));
A.CallTo(() => _entityPathResolver.PathFor(A <IParameter> ._)).ReturnsLazily(s => ((IParameter)s.Arguments[0]).Name);
_allVectorialParameters = new List <IParameter>(new[] { _constantParameter, _formulaParameter1, _formulaParameter2 });
_allAdvancedParameters = new List <IParameter>(new[] { _constantParameter, _formulaParameter1 });
A.CallTo(() => _population.AllVectorialParameters(_entityPathResolver)).Returns(_allVectorialParameters);
A.CallTo(() => _population.AllAdvancedParameters(_entityPathResolver)).Returns(_allAdvancedParameters);
A.CallTo(() => _population.NumberOfItems).Returns(3);
A.CallTo(() => _population.AllGenders()).Returns(new[] { _male, _male, _male });
A.CallTo(() => _population.AllRaces()).Returns(new[] { _american, _american, _american });
}
protected override void Context()
{
_simulation = new IndividualSimulation
{
Properties = new SimulationProperties(),
SimulationSettings = new SimulationSettings(),
ModelConfiguration = new ModelConfiguration()
};
_individual = new Individual().WithName("MyIndividuyal");
_speciesPopulation = new SpeciesPopulation();
_individual.OriginData = new OriginData {
SpeciesPopulation = _speciesPopulation
};
_compound = A.Fake <Compound>().WithName("MyCompound");
_protocol = A.Fake <Protocol>().WithName("MyProtocol");
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Individual", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _individual
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Compound", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _compound
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Protocol", PKSimBuildingBlockType.Protocol)
{
BuildingBlock = _protocol
});
_protocolToProtocolSchemaItemMapper = A.Fake <IProtocolToSchemaItemsMapper>();
sut = new SimulationConfigurationValidator(_protocolToProtocolSchemaItemMapper);
_speciesPopulation.IsHeightDependent = false;
_schemaItem = A.Fake <SchemaItem>();
_doseUnit = A.Fake <Unit>();
_schemaItem.Dose.DisplayUnit = _doseUnit;
A.CallTo(() => _protocolToProtocolSchemaItemMapper.MapFrom(_protocol)).Returns(new [] { _schemaItem });
}
protected override void Context()
{
_speciesRepository = A.Fake <ISpeciesRepository>();
_originDataTask = A.Fake <IOriginDataTask>();
_individualModelTask = A.Fake <IIndividualModelTask>();
_male = new Gender().WithName(CoreConstants.Gender.Male);
_female = new Gender().WithName(CoreConstants.Gender.Female);
_human = new Species().WithName(CoreConstants.Species.Human);
_icrp = new SpeciesPopulation {
IsHeightDependent = true, IsAgeDependent = true
}.WithName(CoreConstants.Population.ICRP);
_anotherPop = new SpeciesPopulation().WithName("Another Pop");
_cmForHuman = new CalculationMethod();
_cmForHuman.AddSpecies(_human.Name);
_icrp.AddGender(_male);
_human.AddPopulation(_icrp);
_category = new CalculationMethodCategory();
_category.Add(_cmForHuman);
A.CallTo(() => _speciesRepository.All()).Returns(new[] { _human });
A.CallTo(() => _originDataTask.AllCalculationMethodCategoryFor(_human)).Returns(new[] { _category });
_batchOriginData = new OriginData();
sut = new OriginDataMapper(_speciesRepository, _originDataTask, _individualModelTask);
}
protected override void Context()
{
base.Context();
_healthyDiseaseState = new DiseaseState {
Name = CoreConstants.DiseaseStates.HEALTHY
};
_pvv1 = new ParameterValueVersion().WithName("PV1");
_pvv2 = new ParameterValueVersion().WithName("PV2");
_parameterHeight = A.Fake <ParameterDTO>();
A.CallTo(() => _parameterHeight.KernelValue).Returns(5);
_parameterWeight = A.Fake <ParameterDTO>();
A.CallTo(() => _parameterWeight.KernelValue).Returns(6);
_parameterAge = A.Fake <ParameterDTO>();
A.CallTo(() => _parameterAge.KernelValue).Returns(7);
_parameterBMI = A.Fake <ParameterDTO>();
A.CallTo(() => _parameterBMI.KernelValue).Returns(10);
_parameterGestationalAge = A.Fake <ParameterDTO>();
A.CallTo(() => _parameterGestationalAge.KernelValue).Returns(25);
_individualSettingsDTO.SetDefaultParameters(_parameterAge, _parameterHeight, _parameterWeight, _parameterBMI, _parameterGestationalAge);
_individualSettingsDTO.CalculationMethods = new List <CategoryCalculationMethodDTO>();
_individualSettingsDTO.DiseaseState = _healthyDiseaseState;
_species = A.Fake <Species>();
_speciesPopulation = A.Fake <SpeciesPopulation>();
_gender = A.Fake <Gender>();
_subPopulationDTO = new List <CategoryParameterValueVersionDTO> {
new CategoryParameterValueVersionDTO {
ParameterValueVersion = _pvv1
}, new CategoryParameterValueVersionDTO {
ParameterValueVersion = _pvv2
}
};
_individualSettingsDTO.Species = _species;
_individualSettingsDTO.SubPopulation = _subPopulationDTO;
_individualSettingsDTO.Population = _speciesPopulation;
_individualSettingsDTO.Gender = _gender;
}
public IndividualSettingsDTO DefaultSettingFor(SpeciesPopulation speciesPopulation)
{
var species = _speciesRepository.FindByName(speciesPopulation.Species);
return(defaultSettingsFor(species, speciesPopulation));
}
private IEnumerable <ParameterDistributionMetaData> distributedParameterMetaDataFor(IEnumerable <ParameterDistributionMetaData> queryableDistributionParameters, SpeciesPopulation population, SubPopulation subPopulation)
{
return(from distribution in queryableDistributionParameters
where distribution.Population == population.Name
where subPopulation.Contains(distribution.ParameterValueVersion)
select distribution);
}
public IReadOnlyList <ParameterDistributionMetaData> ParameterDistributionsFor(IContainer parameterContainer, SpeciesPopulation population, SubPopulation subPopulation, string parameterName)
{
var containerPath = _entityPathResolver.PathFor(parameterContainer);
return(distributedParameterMetaDataFor(_parameterDistributionRepository.AllFor(containerPath), population, subPopulation)
.Where(p => string.Equals(p.ParameterName, parameterName))
.ToList());
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_calculationMethodCacheMapper = A.Fake <CalculationMethodCacheMapper>();
_originDataTask = A.Fake <IOriginDataTask>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_individualModelTask = A.Fake <IIndividualModelTask>();
_speciesRepository = A.Fake <ISpeciesRepository>();
_valueOriginMapper = A.Fake <ValueOriginMapper>();
sut = new OriginDataMapper(_parameterMapper, _calculationMethodCacheMapper, _valueOriginMapper, _originDataTask, _dimensionRepository, _individualModelTask, _speciesRepository);
_ageSnapshotParameter = new Parameter {
Value = 1
};
_heightSnapshotParameter = new Parameter {
Value = 2
};
_weightSnapshotParameter = new Parameter {
Value = 3
};
_gestationalAgeSnapshotParameter = new Parameter {
Value = 4
};
_speciesPopulation = new SpeciesPopulation {
Name = "SpeciesPopulation", IsHeightDependent = true, IsAgeDependent = true
};
_gender = new Gender {
Name = "Unknown"
};
_species = new Species {
Name = "Human"
};
_species.AddPopulation(_speciesPopulation);
_anotherPopulation = new SpeciesPopulation {
Name = "Another species population", IsHeightDependent = true, IsAgeDependent = true
};
_speciesPopulation.AddGender(_gender);
_anotherGender = new Gender {
Name = "AnotherGender"
};
A.CallTo(() => _speciesRepository.All()).Returns(new[] { _species });
_originData = new Model.OriginData
{
Age = 35,
AgeUnit = "years",
Height = 17.8,
HeightUnit = "m",
Weight = 73,
WeightUnit = "kg",
Species = _species,
SpeciesPopulation = _speciesPopulation,
Gender = _gender,
GestationalAge = 40
};
A.CallTo(() => _parameterMapper.ParameterFrom(null, A <string> ._, A <IDimension> ._)).Returns(null);
A.CallTo(() => _parameterMapper.ParameterFrom(_originData.Age, A <string> ._, A <IDimension> ._)).Returns(_ageSnapshotParameter);
A.CallTo(() => _parameterMapper.ParameterFrom(_originData.Height, A <string> ._, A <IDimension> ._)).Returns(_heightSnapshotParameter);
A.CallTo(() => _parameterMapper.ParameterFrom(_originData.Weight, A <string> ._, A <IDimension> ._)).Returns(_weightSnapshotParameter);
A.CallTo(() => _parameterMapper.ParameterFrom(_originData.GestationalAge, A <string> ._, A <IDimension> ._)).Returns(_gestationalAgeSnapshotParameter);
_valueOriginSnapshot = new ValueOrigin();
A.CallTo(() => _valueOriginMapper.MapToSnapshot(_originData.ValueOrigin)).Returns(_valueOriginSnapshot);
return(_completed);
}
public Gender DefaultGenderFor(SpeciesPopulation speciesPopulation)
{
return(speciesPopulation.Genders[0]);
}
public IReadOnlyList<DiseaseState> AllFor(SpeciesPopulation population)
{
Start();
return _allDiseaseStatePerPopulation[population];
}
public Gender DefaultGenderFor(SpeciesPopulation speciesPopulation)
{
return(speciesPopulation.Genders.ElementAt(0));
}
private void updateSettingsFor(IndividualSettingsDTO individualSettingsDTO, Species species, SpeciesPopulation speciesPopulation)
{
individualSettingsDTO.Species = species;
individualSettingsDTO.SpeciesPopulation = speciesPopulation;
individualSettingsDTO.Gender = DefaultGenderFor(speciesPopulation);
individualSettingsDTO.CalculationMethods = individualCalculationMethods(species);
}
public IEnumerable <Gender> GenderFor(SpeciesPopulation speciesPopulation)
{
return(speciesPopulation.Genders);
}
