protected override Task Context()
{
_quantityInfoMapper = A.Fake <QuantityInfoMapper>();
_dataInfoMapper = A.Fake <DataInfoMapper>();
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new DataColumnMapper(_dataInfoMapper, _quantityInfoMapper, _dimensionRepository);
var observedData = DomainHelperForSpecs.ObservedData();
_dataColumn = observedData.ObservationColumns().First();
_baseGrid = observedData.BaseGrid;
_relatedColumn = new DataColumn("related", DomainHelperForSpecs.NoDimension(), observedData.BaseGrid)
{
Values = new[] { 0f, 0f, 0f },
DataInfo = { Origin = ColumnOrigins.ObservationAuxiliary }
};
_dataColumn.AddRelatedColumn(_relatedColumn);
_quantityInfoSnapshot = new Snapshots.QuantityInfo();
_dataInfoSnapshot = new Snapshots.DataInfo();
A.CallTo(() => _quantityInfoMapper.MapToSnapshot(_dataColumn.QuantityInfo)).Returns(_quantityInfoSnapshot);
A.CallTo(() => _dataInfoMapper.MapToSnapshot(_dataColumn.DataInfo)).Returns(_dataInfoSnapshot);
A.CallTo(() => _dimensionRepository.DimensionByName(_dataColumn.Dimension.Name)).Returns(_dataColumn.Dimension);
A.CallTo(() => _dimensionRepository.DimensionByName(_baseGrid.Dimension.Name)).Returns(_baseGrid.Dimension);
return(Task.FromResult(true));
}
protected override Task Context()
{
_formulaFactory = A.Fake <IFormulaFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new TableFormulaMapper(_formulaFactory, _dimensionRepository);
_tableFormula = new TableFormula
{
XName = "pH",
YName = "Value",
XDimension = DomainHelperForSpecs.TimeDimensionForSpecs(),
Dimension = DomainHelperForSpecs.LengthDimensionForSpecs(),
Name = "SUPER_FORMULA"
};
_tableFormula.XDisplayUnit = _tableFormula.XDimension.Unit("h");
_tableFormula.YDisplayUnit = _tableFormula.Dimension.Unit("cm");
_tableFormula.UseDerivedValues = true;
_tableFormula.AddPoint(60, 1); //60 min, 1m
_tableFormula.AddPoint(120, 2); //120 min, 2m
_tableFormula.AllPoints().ElementAt(1).RestartSolver = true;
A.CallTo(() => _dimensionRepository.DimensionByName(_tableFormula.XDimension.Name)).Returns(_tableFormula.XDimension);
A.CallTo(() => _dimensionRepository.DimensionByName(_tableFormula.Dimension.Name)).Returns(_tableFormula.Dimension);
return(Task.FromResult(true));
}
private void convertIndividualParameters(IContainer organism)
{
organism.Parameter(ConverterConstants.Parameter.A_to_V_bc).Value *= 10;
organism.Parameter(ConverterConstants.Parameter.A_to_V_bc).Dimension = _dimensionRepository.DimensionByName(CoreConstants.Dimension.InversedLength);
organism.Parameter(ConverterConstants.Parameter.PARAM_k_SA).Value /= 100;
organism.Parameter(ConverterConstants.Parameter.PARAM_k_SA).Dimension = _dimensionRepository.DimensionByName(CoreConstants.Dimension.InversedLength);
}
public virtual void UpdateModelProperties(ModelTableFormula tableFormula, SnapshotTableFormula snapshotTableFormula)
{
tableFormula.XDimension = _dimensionRepository.DimensionByName(snapshotTableFormula.XDimension);
tableFormula.XDisplayUnit = tableFormula.XDimension.Unit(ModelValueFor(snapshotTableFormula.XUnit));
tableFormula.XName = snapshotTableFormula.XName;
tableFormula.Dimension = _dimensionRepository.DimensionByName(snapshotTableFormula.YDimension);
tableFormula.YDisplayUnit = tableFormula.Dimension.Unit(ModelValueFor(snapshotTableFormula.YUnit));
tableFormula.YName = snapshotTableFormula.YName;
tableFormula.UseDerivedValues = snapshotTableFormula.UseDerivedValues;
snapshotTableFormula.Points.Each(p => tableFormula.AddPoint(valuePointFrom(tableFormula, p)));
}
public IFormulaUsablePath MapFrom(FlatRateObjectPath flatRateObjectPath)
{
var rateObjectContainerPath = _objectPathMapper.MapFrom(flatRateObjectPath);
return(_objectPathFactory.CreateFormulaUsablePathFrom(rateObjectContainerPath.ToArray())
.WithAlias(flatRateObjectPath.Alias)
.WithDimension(_dimensionRepository.DimensionByName(flatRateObjectPath.Dimension)));
}
private void mapNumericFieldToModel(PopulationAnalysisField snapshot, INumericValueField field)
{
field.Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension);
var optimalDimension = _dimensionRepository.MergedDimensionFor(field);
field.DisplayUnit = optimalDimension.Unit(ModelValueFor(snapshot.Unit));
field.Scaling = ModelValueFor(snapshot.Scaling, field.Scaling);
}
private IFormula createFormula(RateKey rateKey)
{
if (rateKey.IsBlackBoxFormula)
{
return(_objectBaseFactory.Create <BlackBoxFormula>()
.WithId(rateKey)
.WithName(rateKey.Rate));
}
if (rateKey.IsTableWithOffsetFormula)
{
return(createTableFormulaWithOffset(rateKey));
}
if (rateKey.IsTableWithXArgumentFormula)
{
return(createTableFormulaWithArgument(rateKey));
}
//now it can be either dynamic formula or explicit formula
FormulaWithFormulaString formula;
if (rateKey.IsDynamicSumFormula)
{
var sumFormula = _objectBaseFactory.Create <SumFormula>();
sumFormula.Criteria = _dynamicFormulaCriteriaRepository.CriteriaFor(rateKey).Clone();
formula = sumFormula;
}
else
{
formula = _objectBaseFactory.Create <ExplicitFormula>();
}
formula.WithFormulaString(_rateFormulaRepository.FormulaFor(rateKey))
.WithId(rateKey)
.WithName(rateKey.Rate);
foreach (var rateObjectPath in _rateObjectPathsRepository.ObjectPathsFor(rateKey))
{
formula.AddObjectPath(rateObjectPath.Clone <IFormulaUsablePath>());
}
addTimeReferenceIfNeeded(formula);
//set formula dimension if available
var dimensionName = _rateFormulaRepository.DimensionNameFor(rateKey);
var dimension = _dimensionRepository.DimensionByName(dimensionName);
formula.Dimension = dimension;
if (formula.ObjectPaths.Any() || formula.IsAnImplementationOf <DynamicFormula>())
{
return(formula);
}
//this is actually a constant formula! Evaluate the function and return a contant formula
return(constantFormula(formula.Calculate(null)).WithDimension(dimension));
}
public override async Task <ModelExplicitFormula> MapToModel(SnapshotExplicitFormula snapshot, SnapshotContext snapshotContext)
{
var formula = _objectBaseFactory.Create <ModelExplicitFormula>();
MapSnapshotPropertiesToModel(snapshot, formula);
formula.FormulaString = snapshot.Formula;
formula.Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension);
var objectsPaths = await _formulaUsablePathMapper.MapToModels(snapshot.References, snapshotContext);
objectsPaths?.Each(formula.AddObjectPath);
return(formula);
}
protected override Task Context()
{
_descriptorConditionMapper = A.Fake <DescriptorConditionMapper>();
_explicitFormulaMapper = A.Fake <ExplicitFormulaMapper>();
_moleculeListMapper = A.Fake <MoleculeListMapper>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_logger = A.Fake <ILogger>();
_dimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_amountObserver = new AmountObserverBuilder {
Dimension = _dimension
};
_containerObserver = new ContainerObserverBuilder {
Dimension = _dimension
};
_formula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("1+2");
_amountObserver.Formula = _formula;
_containerObserver.Formula = _formula;
_moleculeListSnapshot = new MoleculeList();
_snapshotFormula = new ExplicitFormula();
_newMoleculeList = new OSPSuite.Core.Domain.Builder.MoleculeList();
_newMoleculeList.AddMoleculeNameToExclude("A");
_newMoleculeList.AddMoleculeName("B");
_newMoleculeList.ForAll = false;
_newFormula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("New");
sut = new ObserverMapper(
_descriptorConditionMapper,
_explicitFormulaMapper,
_moleculeListMapper,
_objectBaseFactory,
_dimensionRepository,
_logger);
A.CallTo(() => _explicitFormulaMapper.MapToSnapshot(_formula)).Returns(_snapshotFormula);
A.CallTo(() => _explicitFormulaMapper.MapToModel(_snapshotFormula)).Returns(_newFormula);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_amountObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_containerObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToModel(_moleculeListSnapshot)).Returns(_newMoleculeList);
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
A.CallTo(() => _objectBaseFactory.Create <AmountObserverBuilder>()).Returns(new AmountObserverBuilder());
A.CallTo(() => _objectBaseFactory.Create <ContainerObserverBuilder>()).Returns(new ContainerObserverBuilder());
return(_completed);
}
private void setParameterProperties(IParameter parameter, ParameterMetaData parameterMetaData)
{
parameter.Name = parameterMetaData.ParameterName;
parameter.BuildMode = parameterMetaData.BuildMode;
parameter.Info = parameterMetaData.Clone();
parameter.Dimension = _dimensionRepository.DimensionByName(parameterMetaData.Dimension);
if (!string.IsNullOrEmpty(parameterMetaData.DefaultUnit))
{
parameter.DisplayUnit = parameter.Dimension.Unit(parameterMetaData.DefaultUnit);
}
parameter.DisplayUnit = _displayUnitRetriever.PreferredUnitFor(parameter);
}
public IPKSimObserverBuilder MapFrom(FlatObserver flatObserver)
{
var observerBuilder = createObserverBuilderByType(flatObserver);
var pksimObserverBuilder = new PKSimObserverBuilder(observerBuilder);
observerBuilder.Name = flatObserver.Name;
observerBuilder.ForAll = flatObserver.ForAllMolecules;
pksimObserverBuilder.CalculationMethod = flatObserver.CalculationMethod;
pksimObserverBuilder.Rate = flatObserver.Rate;
observerBuilder.Formula = _formulaFactory.RateFor(pksimObserverBuilder, new FormulaCache());
observerBuilder.Dimension = _dimensionRepository.DimensionByName(flatObserver.Dimension);
return(pksimObserverBuilder);
}
public override Task <IFormulaUsablePath> MapToModel(SnapshotFormulaUsablePath snapshot)
{
IFormulaUsablePath formulaUsablePath;
if (snapshot.Alias == Constants.TIME)
{
formulaUsablePath = new TimePath();
}
else
{
formulaUsablePath = new OSPSuite.Core.Domain.FormulaUsablePath(snapshot.Path.ToPathArray())
{
Alias = snapshot.Alias,
Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension),
};
}
return(Task.FromResult(formulaUsablePath));
}
protected override Task Context()
{
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new GroupingDefinitionMapper(_dimensionRepository);
_groupingItem1 = new GroupingItem();
_groupingItem2 = new GroupingItem();
_dimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_unit = _dimension.Unit("h");
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
_valueMappingGrouping = new ValueMappingGroupingDefinition("F1");
_valueMappingGrouping.AddValueLabel("Item1", _groupingItem1);
_valueMappingGrouping.AddValueLabel("Item2", _groupingItem2);
_fixedLimitGrouping = new FixedLimitsGroupingDefinition("F1")
{
DisplayUnit = _unit,
Dimension = _dimension,
};
_fixedLimitGrouping.SetLimits(new[] { 60, 120.0 }.OrderBy(x => x));
_fixedLimitGrouping.AddItem(_groupingItem1);
_fixedLimitGrouping.AddItem(_groupingItem2);
_numberOfBinsGrouping = new NumberOfBinsGroupingDefinition("F1")
{
DisplayUnit = _unit,
Dimension = _dimension,
NumberOfBins = 4,
NamingPattern = "TOTO",
StartColor = Color.Aqua,
EndColor = Color.Red,
Strategy = LabelGenerationStrategies.Numeric
};
_numberOfBinsGrouping.AddItem(_groupingItem1);
_numberOfBinsGrouping.AddItem(_groupingItem2);
return(_completed);
}
public override Task <ModelAxis> MapToModel(SnapshotAxis snapshot, SnapshotContext snapshotContext)
{
var axis = new ModelAxis(snapshot.Type)
{
Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension),
Caption = snapshot.Caption,
GridLines = snapshot.GridLines,
Visible = snapshot.Visible,
DefaultColor = snapshot.DefaultColor,
DefaultLineStyle = snapshot.DefaultLineStyle,
Scaling = snapshot.Scaling,
NumberMode = snapshot.NumberMode
};
axis.Dimension = _dimensionRepository.OptimalDimensionFor(axis.Dimension);
axis.UnitName = ModelValueFor(snapshot.Unit);
axis.Min = snapshot.Min;
axis.Max = snapshot.Max;
return(Task.FromResult(axis));
}
public override async Task <ModelObserver> MapToModel(SnapshotObserver snapshot)
{
var observer = createObserverFrom(snapshot);
if (observer == null)
{
return(null);
}
MapSnapshotPropertiesToModel(snapshot, observer);
observer.Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension);
var allDescriptorConditions = await _descriptorConditionMapper.MapToModels(snapshot.ContainerCriteria);
observer.ContainerCriteria = new DescriptorCriteria();
allDescriptorConditions?.Each(observer.ContainerCriteria.Add);
observer.Formula = await _explicitFormulaMapper.MapToModel(snapshot.Formula);
var moleculeList = await _moleculeListMapper.MapToModel(snapshot.MoleculeList);
observer.MoleculeList.Update(moleculeList);
return(observer);
}
protected override Task Context()
{
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new AxisMapper(_dimensionRepository);
_dimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_axis = new Axis(AxisTypes.Y)
{
Caption = "Axis Caption",
GridLines = true,
Dimension = _dimension,
UnitName = _dimension.Unit("h").Name,
Visible = true,
Min = 60, //min
Max = 120,
DefaultColor = Color.AntiqueWhite,
DefaultLineStyle = LineStyles.Solid
};
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
return(_completed);
}
protected override Task Context()
{
_dimensionRepository = A.Fake <IDimensionRepository>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_formulaUsablePathMapper = new FormulaUsablePathMapper(_dimensionRepository);
sut = new ExplicitFormulaMapper(_objectBaseFactory, _formulaUsablePathMapper, _dimensionRepository);
_dimension1 = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_dimension2 = DomainHelperForSpecs.TimeDimensionForSpecs();
_formula = new ExplicitFormula("P1+P2+P3+P4")
{
Dimension = _dimension1
};
_formula.AddObjectPath(new FormulaUsablePath("A", "B", "C")
{
Alias = "P1", Dimension = _dimension1
});
_formula.AddObjectPath(new FormulaUsablePath("A", "B")
{
Alias = "P2", Dimension = _dimension2
});
_formula.AddObjectPath(new FormulaUsablePath("A")
{
Alias = "P3", Dimension = Constants.Dimension.NO_DIMENSION
});
_formula.AddObjectPath(new FormulaUsablePath("A")
{
Alias = "P4"
});
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension1.Name)).Returns(_dimension1);
A.CallTo(() => _objectBaseFactory.Create <ExplicitFormula>()).Returns(new ExplicitFormula());
return(_completed);
}
protected override Task Context()
{
_groupingDefinitionMapper = A.Fake <GroupingDefinitionMapper>();
_dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_mergedDimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_unit = _mergedDimension.Unit("h"); // this unit is defined in the merged dimension but not in the field dimension
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new PopulationAnalysisFieldMapper(_groupingDefinitionMapper, _dimensionRepository);
_groupingItem1 = new GroupingItem();
_parameterField = new PopulationAnalysisParameterField
{
Name = "P",
ParameterPath = "A|B",
Scaling = Scalings.Linear,
Dimension = _dimension,
DisplayUnit = _unit
};
_pkParameterField = new PopulationAnalysisPKParameterField
{
Name = "PK",
Dimension = _dimension,
DisplayUnit = _unit,
PKParameter = "AUC",
QuantityPath = "A|B|C",
QuantityType = QuantityType.Observer | QuantityType.Drug
};
_outputField = new PopulationAnalysisOutputField
{
Name = "Output",
Dimension = _dimension,
DisplayUnit = _unit,
QuantityType = QuantityType.BaseGrid,
QuantityPath = "A|B|C",
Color = Color.AntiqueWhite
};
_groupingDefinition = new FixedLimitsGroupingDefinition("AA");
_groupingField = new PopulationAnalysisGroupingField(_groupingDefinition)
{
Name = "Grouping",
};
_covariateField = new PopulationAnalysisCovariateField
{
Name = "Gender",
Covariate = "Gender",
};
_covariateField.AddGroupingItem(_groupingItem1);
_snapshotGroupingDefinition = new Snapshots.GroupingDefinition();
A.CallTo(() => _groupingDefinitionMapper.MapToSnapshot(_groupingDefinition)).Returns(_snapshotGroupingDefinition);
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <INumericValueField> ._)).Returns(_mergedDimension);
return(_completed);
}
public DataInfoMapper(ExtendedPropertyMapper extendedPropertyMapper, IDimensionRepository dimensionRepository)
{
_molWeightDimension = dimensionRepository.DimensionByName(Constants.Dimension.MOLECULAR_WEIGHT);
_extendedPropertyMapper = extendedPropertyMapper;
}
private void mapIntervalGroupingToModel(SnapshotGroupingDefinition snapshot, IntervalGroupingDefinition groupingDefinition)
{
groupingDefinition.Dimension = _dimensionRepository.DimensionByName(snapshot.Dimension);
groupingDefinition.DisplayUnit = groupingDefinition.Dimension.UnitOrDefault(ModelValueFor(snapshot.Unit));
groupingDefinition.AddItems(snapshot.Items);
}
private IDimension dimensionFrom(SnapshotDataColumn snapshot)
{
return(_dimensionRepository.DimensionByName(snapshot.Dimension));
}
