public void Convert(IMoleculeStartValue moleculeStartValue, IFormulaCache formulaCache) { if (!conversionRequired(moleculeStartValue)) { return; } moleculeStartValue.Dimension = _concentrationDimension; moleculeStartValue.DisplayUnit = _displayUnitRetriever.PreferredUnitFor(moleculeStartValue); if (moleculeStartValue.Formula.IsExplicit()) { convertExplicitFormula(moleculeStartValue.Formula, _concentrationDimension); return; } var startValue = moleculeStartValue.StartValue.GetValueOrDefault(0); if (startValue == 0) { return; } moleculeStartValue.Formula = createConcentrationFormulaFromConstantValue(startValue, moleculeStartValue.Path.ToPathString(), formulaCache); }
public IParameter CreateConcentrationParameterIn(IFormulaCache formulaCache) { var parameter = CreateFor(CoreConstants.Parameters.CONCENTRATION, PKSimBuildingBlockType.Simulation); parameter.BuildMode = ParameterBuildMode.Local; parameter.Info.Visible = false; parameter.Formula = _formulaFactory.ConcentrationFormulaFor(formulaCache); parameter.Dimension = _dimensionRepository.MolarConcentration; parameter.DisplayUnit = _displayUnitRetriever.PreferredUnitFor(parameter); return(parameter); }
private void updateChart() { var xUnit = _displayUnitRetriever.PreferredUnitFor(_dimensionRepository.AgeInYears); var yUnit = _displayUnitRetriever.PreferredUnitFor(_dimensionRepository.Fraction); var chart = _simpleChartPresenter.Plot(dataForSelectedOntogeny(xUnit, yUnit), Scalings.Linear); chart.Axes[AxisTypes.X].Caption = PKSimConstants.UI.PostMenstrualAge; chart.Axes[AxisTypes.X].GridLines = true; chart.Axes[AxisTypes.Y].Caption = PKSimConstants.UI.OntogenyFor(_dto.SelectedOntogeny.Name); chart.Axes[AxisTypes.Y].GridLines = true; }
private IParameter createPKParameter(string name, double value, string dimension) { var parameter = _parameterFactory.CreateFor(name, value, dimension, PKSimBuildingBlockType.Simulation); parameter.Dimension = _dimensionRepository.MergedDimensionFor(parameter); parameter.DisplayUnit = _displayUnitRetriever.PreferredUnitFor(parameter); parameter.Rules.Clear(); return(parameter); }
public override void Compare(IComparison <ConstantFormula> comparison) { if (!comparison.Settings.CompareHiddenEntities) { return; } CompareDoubleValues(x => x.Value, x => x.Value, comparison, x => _displayUnitRetriever.PreferredUnitFor(x)); CompareValues(x => x.Dimension, x => x.Dimension, comparison); }
protected void UpdateParameterDisplayUnit(IEnumerable <IQuantity> quantities, IPresentationSettings presentationSettings) { quantities.Each(p => { var preferredUnit = _displayUnitRetriever.PreferredUnitFor(p); var unitName = presentationSettings.GetSetting(p.Name, preferredUnit.Name); p.DisplayUnit = p.Dimension.UnitOrDefault(unitName); }); }
private AdvancedProtocol createAdvancedProtocol(ApplicationType applicationType) { var protocol = _objectBaseFactory.Create <AdvancedProtocol>(); protocol.Root = _objectBaseFactory.Create <IRootContainer>(); protocol.TimeUnit = _displayUnitRetriever.PreferredUnitFor(_dimensionRepository.Time); var schema = _schemaFactory.CreateWithDefaultItem(applicationType, protocol); protocol.AddSchema(schema); return(protocol); }
protected override void Context() { _dimensionRepository = A.Fake <IDimensionRepository>(); _displayUnitRetriever = A.Fake <IDisplayUnitRetriever>(); sut = new PopulationAnalysisFactory(_dimensionRepository, _displayUnitRetriever); var timeDimension = A.Fake <IDimension>(); _defaultUnit = A.Fake <Unit>(); A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(timeDimension)).Returns(_defaultUnit); A.CallTo(() => _dimensionRepository.Time).Returns(timeDimension); }
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() { _presentationSettingsTask = A.Fake <IPresentationSettingsTask>(); _displayUnitRetriever = A.Fake <IDisplayUnitRetriever>(); sut = new PresentableTeXBuilderForSpecs(_presentationSettingsTask, _displayUnitRetriever); _parameter1 = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P1"); _parameter1.Dimension = DomainHelperForSpecs.LengthDimensionForSpecs(); _parameter2 = DomainHelperForSpecs.ConstantParameterWithValue(2).WithName("P2"); _parameter2.Dimension = DomainHelperForSpecs.TimeDimensionForSpecs(); _parameter3 = DomainHelperForSpecs.ConstantParameterWithValue(3).WithName("P3"); _parameter3.Dimension = DomainHelperForSpecs.LengthDimensionForSpecs(); _container = new Container { _parameter1, _parameter2, _parameter3, }.WithId("Id"); _presentationSettings = new DefaultPresentationSettings(); //existing unit _presentationSettings.SetSetting(_parameter1.Name, "cm"); //wrong unit for dimension _presentationSettings.SetSetting(_parameter2.Name, "cm"); A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(_parameter1)).Returns(_parameter1.Dimension.BaseUnit); A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(_parameter2)).Returns(_parameter2.Dimension.BaseUnit); //wrong preferred unit. A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(_parameter3)).Returns(_parameter2.Dimension.DefaultUnit); A.CallTo(_presentationSettingsTask).WithReturnType <DefaultPresentationSettings>().Returns(_presentationSettings); }
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); }
protected override void Context() { _schemaFactory = A.Fake <ISchemaFactory>(); _objectBaseFactory = A.Fake <IObjectBaseFactory>(); _parameterFactory = A.Fake <IParameterFactory>(); _dimensionRepository = A.Fake <IDimensionRepository>(); _schemaItemParameterRetriever = A.Fake <ISchemaItemParameterRetriever>(); _displayUnitRetriever = A.Fake <IDisplayUnitRetriever>(); sut = new ProtocolFactory(_objectBaseFactory, _schemaFactory, _parameterFactory, _dimensionRepository, _schemaItemParameterRetriever, _displayUnitRetriever); _timeDimension = A.Fake <IDimension>(); _doseDimension = A.Fake <IDimension>(); _defaultTimeUnit = A.Fake <Unit>(); A.CallTo(() => _dimensionRepository.Mass).Returns(_doseDimension); A.CallTo(() => _dimensionRepository.Time).Returns(_timeDimension); A.CallTo(() => _displayUnitRetriever.PreferredUnitFor(_timeDimension)).Returns(_defaultTimeUnit); }
public PopulationStatisticalAnalysis CreateStatisticalAnalysis() { var statisticalAnalysis = new PopulationStatisticalAnalysis { TimeUnit = _displayUnitRetriever.PreferredUnitFor(_dimensionRepository.Time) }; //add predefined single curve selection EnumHelper.AllValuesFor <StatisticalAggregationType>() .Each(x => statisticalAnalysis.AddStatistic(new PredefinedStatisticalAggregation { Method = x })); CoreConstants.DEFAULT_STATISTIC_PERCENTILES.Each(p => statisticalAnalysis.AddStatistic(new PercentileStatisticalAggregation { Percentile = p })); return(statisticalAnalysis); }
private DataColumn createColumn(BaseGrid xValues, IQuantity quantity, IValues yValues, IEnumerable <string> quantityPath, IModelCoreSimulation simulation) { var column = new DataColumn(_dataNamingService.GetEntityName(yValues.EntityId), quantity.Dimension, xValues) { DataInfo = { Origin = ColumnOrigins.Calculation, ComparisonThreshold = (float)yValues.ComparisonThreshold }, Values = new List <float>(yValues.Values.ToFloatArray()), QuantityInfo = new QuantityInfo(yValues.Name, quantityPath, quantity.QuantityType), DisplayUnit = _displayUnitRetriever.PreferredUnitFor(quantity) }; _dataRepositoryTask.UpdateMolWeight(column, quantity, simulation.Model); return(column); }
private void plotContinousData <TObject>(IPopulationDataCollector populationDataCollector, TObject objectToPlot, INumericValueField numericValueField, Func <IPopulationDistributionPresenter, Action <IPopulationDataCollector, TObject, DistributionSettings, IDimension, Unit> > plotFunc) where TObject : class, IWithDimension { if (objectToPlot == null) { return; } var displayUnit = _displayUnitRetriever.PreferredUnitFor(objectToPlot); var dimension = objectToPlot.Dimension; var settings = new DistributionSettings(); if (numericValueField != null) { displayUnit = numericValueField.DisplayUnit; settings.PlotCaption = numericValueField.Name; dimension = _dimensionRepository.MergedDimensionFor(new NumericFieldContext(numericValueField, populationDataCollector)); } plotFunc(_populationDistributionPresenter)(populationDataCollector, objectToPlot, settings, dimension, displayUnit); }
private DataTable createPKAnalysesDataToExport(PopulationSimulation populationSimulation) { var dataTable = new DataTable(populationSimulation.Name); if (!populationSimulation.HasPKAnalyses) { return(dataTable); } var pkAnalyses = populationSimulation.PKAnalyses; dataTable.AddColumn <int>(CoreConstants.SimulationResults.INDIVIDUAL_ID); dataTable.AddColumn <string>(CoreConstants.SimulationResults.QUANTITY_PATH); dataTable.AddColumn <string>(CoreConstants.SimulationResults.PARAMETER); dataTable.AddColumn <string>(CoreConstants.SimulationResults.VALUE); dataTable.AddColumn <string>(CoreConstants.SimulationResults.UNIT); dataTable.BeginLoadData(); foreach (var pkParameter in pkAnalyses.All()) { var parameter = pkParameter; var unit = _displayUnitRetriever.PreferredUnitFor(parameter); parameter.Values.Each((value, index) => { var row = dataTable.NewRow(); row[CoreConstants.SimulationResults.INDIVIDUAL_ID] = index; row[CoreConstants.SimulationResults.QUANTITY_PATH] = parameter.QuantityPath; row[CoreConstants.SimulationResults.PARAMETER] = parameter.Name; row[CoreConstants.SimulationResults.VALUE] = parameter.ConvertToUnit(value, unit).ConvertedTo <string>(); row[CoreConstants.SimulationResults.UNIT] = unit.Name; dataTable.Rows.Add(row); }); } dataTable.EndLoadData(); return(dataTable); }
public void UpdateDimension(ParameterStartValueDTO startValueObject, IDimension newDimension) { var macroCommand = new MoBiMacroCommand(); var startValue = StartValueFrom(startValueObject); macroCommand.CommandType = AppConstants.Commands.EditCommand; macroCommand.Description = AppConstants.Commands.UpdateDimensionsAndUnits; macroCommand.ObjectType = new ObjectTypeResolver().TypeFor <ParameterStartValue>(); var value = startValue.ConvertToDisplayUnit(startValue.StartValue); macroCommand.AddCommand(_parameterStartValuesTask.UpdateStartValueDimension(_buildingBlock, startValue, newDimension)); macroCommand.AddCommand(_parameterStartValuesTask.SetStartDisplayValueWithUnit(startValue, value, _displayUnitRetriever.PreferredUnitFor(startValue), _buildingBlock)); AddCommand(macroCommand); }
public Unit GetDisplayUnitFor(IDimension dimension) { return(_displayUnitRetriever.PreferredUnitFor(dimension) ?? dimension.DefaultUnit); }
public void Plot(IVectorialParametersContainer vectorialParametersContainer, IParameter parameter, DistributionSettings settings = null, IDimension dimension = null, Unit displayUnit = null) { var displayUnitToUse = displayUnit ?? _displayUnitRetriever.PreferredUnitFor(parameter); plot(vectorialParametersContainer, parameter, _distributionDataCreator.CreateFor, updatePlotOptionsDefaultsFor, settings, dimension, displayUnitToUse); }
private void adjustAxes(DataColumn calculatedColumn) { Chart.AxisBy(AxisTypes.Y).UnitName = _displayUnitRetriever.PreferredUnitFor(calculatedColumn).Name; }
private void adjustAxes(DataColumn calculationColumn, ParameterIdentificationPredictedVsObservedChart chart) { chart.AxisBy(AxisTypes.Y).UnitName = _displayUnitRetriever.PreferredUnitFor(calculationColumn).Name; }
public OutputSchema Create() { return(create(CoreConstants.DEFAULT_PROTOCOL_END_TIME_IN_MIN, _displayUnitRetriever.PreferredUnitFor(_dimensionRepository.Time))); }
private void updateDisplayUnit(IWithDisplayUnit withDisplayUnit) { withDisplayUnit.DisplayUnit = _displayUnitRetriever.PreferredUnitFor(withDisplayUnit); }