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)); }