private ObservedCurveData mapFrom(DataColumn observedDataColumn, ObservedDataCurveOptions observedDataCurveOptions, IDimension yAxisDimension)
{
var observedCurve = createCurveData(observedDataColumn, observedDataCurveOptions);
var errorColumn = errorColumnFor(observedDataColumn);
var baseGrid = observedDataColumn.BaseGrid;
var yDimension = _dimensionRepository.MergedDimensionFor(observedDataColumn);
var yErrorDimension = yDimension;
if (observedCurve.ErrorType == AuxiliaryType.GeometricStdDev)
{
yErrorDimension = errorColumn.Dimension;
}
baseGrid.Values.Each((value, i) =>
{
var observedDataYValue = new ObservedDataYValue
{
Mean = convertToAxisBaseValue(yAxisDimension, yDimension, observedDataColumn[i]),
ErrorType = observedCurve.ErrorType,
Error = convertToAxisBaseValue(yAxisDimension, yErrorDimension, errorColumn[i])
};
observedCurve.Add(new TimeProfileXValue(value), observedDataYValue);
});
return(observedCurve);
}
public PopulationAnalysisFieldDTO MapFrom(IPopulationAnalysisField field)
{
return(new PopulationAnalysisFieldDTO(field)
{
Dimension = _dimensionRepository.MergedDimensionFor(field)
});
}
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 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);
}
private IndividualPKAnalysis calculatePKFor(DataColumn dataColumn, string moleculeName, PKCalculationOptions options, GlobalPKAnalysis globalPKAnalysis = null)
{
var timeValue = dataColumn.BaseGrid.Values;
var dimension = _dimensionRepository.MergedDimensionFor(dataColumn);
var umolPerLiterUnit = dimension.UnitOrDefault(CoreConstants.Units.MicroMolPerLiter);
var concentrationValueInMolL = dataColumn.Values.Select(v => dimension.BaseUnitValueToUnitValue(umolPerLiterUnit, v)).ToArray();
var pkAnalysis = _pkMapper.MapFrom(dataColumn, _pkValuesCalculator.CalculatePK(timeValue, concentrationValueInMolL, options), options.PKParameterMode, moleculeName);
addWarningsTo(pkAnalysis, globalPKAnalysis, moleculeName);
return(new IndividualPKAnalysis(dataColumn, pkAnalysis));
}
protected override void Context()
{
_dimensionRepository = A.Fake <IDimensionRepository>();
_representationInfoRepository = A.Fake <IRepresentationInfoRepository>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_observedCurveDataMapper = A.Fake <IDataRepositoryToObservedCurveDataMapper>();
_statisticalAnalysis = new PopulationStatisticalAnalysis();
_genderField = ChartDataHelperForSpecs.CreateGenderField();
_statisticalAnalysis.Add(_genderField);
_statisticalAnalysis.Add(_outputFieldVenousBloodPlasma);
_statisticalAnalysis.Add(_outputFieldLiverCell);
_predefinedStatisticalAggregation = new PredefinedStatisticalAggregation {
Selected = true
};
_percentileStatisticalAggregation = new PercentileStatisticalAggregation {
Selected = false, Percentile = 50
};
_statisticalAnalysis.AddStatistic(_predefinedStatisticalAggregation);
_statisticalAnalysis.AddStatistic(_percentileStatisticalAggregation);
A.CallTo(() => _representationInfoRepository.DisplayNameFor(_predefinedStatisticalAggregation)).Returns(_singleCurveId);
A.CallTo(() => _representationInfoRepository.DisplayNameFor(_percentileStatisticalAggregation)).Returns(_percentileId);
_statisticalDataCalculator = new StatisticalDataCalculator();
_pivotResultCreator = A.Fake <IPivotResultCreator>();
_mergedDimensionVenousBloodPlasma = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_mergedDimensionLiverCell = DomainHelperForSpecs.FractionDimensionForSpecs();
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <IWithDimension> ._))
.WhenArgumentsMatch((IWithDimension context) => Equals((context as NumericFieldContext)?.NumericValueField, _outputFieldVenousBloodPlasma))
.Returns(_mergedDimensionVenousBloodPlasma);
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <IWithDimension> ._))
.WhenArgumentsMatch((IWithDimension context) => Equals((context as NumericFieldContext)?.NumericValueField, _outputFieldLiverCell))
.Returns(_mergedDimensionLiverCell);
sut = new TimeProfileChartDataCreator(_dimensionRepository, _pivotResultCreator, _representationInfoRepository,
_statisticalDataCalculator, _lazyLoadTask, _observedCurveDataMapper);
}
protected virtual AxisData CreateAxisDataFor(INumericValueField axisField)
{
if (axisField == null)
{
return(new AxisData(_dimensionRepository.NoDimension, _dimensionRepository.NoDimension.DefaultUnit, Scalings.Linear));
}
var mergedDimension = _dimensionRepository.MergedDimensionFor(new NumericFieldContext(axisField, _populationDataCollector));
return(new AxisData(mergedDimension, axisField.DisplayUnit, axisField.Scaling)
{
Caption = Constants.NameWithUnitFor(axisField.Name, axisField.DisplayUnit)
});
}
protected override void Context()
{
_view = A.Fake <IEditTimeProfileAnalysisChartView>();
_timeProfilerChartPresenter = A.Fake <ITimeProfileChartPresenter>();
_timeProfileChartDataCreator = A.Fake <ITimeProfileChartDataCreator>();
_populationSimulationAnalysisStarter = A.Fake <IPopulationSimulationAnalysisStarter>();
_populationAnalysisTask = A.Fake <IPopulationAnalysisTask>();
_colorGenerator = A.Fake <IColorGenerator>();
_observedDataTask = A.Fake <IObservedDataTask>();
_pkAnalysisPresenter = A.Fake <IPopulationPKAnalysisPresenter>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_presenterSettingsTask = A.Fake <IPresentationSettingsTask>();
sut = new EditTimeProfileAnalysisChartPresenter(_view, _timeProfilerChartPresenter, _timeProfileChartDataCreator,
_populationSimulationAnalysisStarter, _populationAnalysisTask, _colorGenerator, _observedDataTask, _pkAnalysisPresenter, _dimensionRepository, _presenterSettingsTask);
_timeProfileAnalysisChart = new TimeProfileAnalysisChart();
_populationStatisticalAnalysis = new PopulationStatisticalAnalysis();
_timeProfileAnalysisChart.PopulationAnalysis = _populationStatisticalAnalysis;
_populationDataCollector = A.Fake <IPopulationDataCollector>();
sut.InitializeAnalysis(_timeProfileAnalysisChart, _populationDataCollector);
_observedDataRepository = DomainHelperForSpecs.ObservedData();
var data = new DragDropInfo(
new List <ITreeNode> {
new ObservedDataNode(new ClassifiableObservedData {
Subject = _observedDataRepository
})
}
);
_dragEventArgs = new DragEventArgs(new DataObject(data), 0, 0, 0, DragDropEffects.All, DragDropEffects.All);
_chartData = new ChartData <TimeProfileXValue, TimeProfileYValue>(null, null);
var concentrationDimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
var yAxis = new AxisData(concentrationDimension, concentrationDimension.DefaultUnit, Scalings.Linear);
_paneData = new PaneData <TimeProfileXValue, TimeProfileYValue>(yAxis);
_chartData.AddPane(_paneData);
A.CallTo(_timeProfileChartDataCreator).WithReturnType <ChartData <TimeProfileXValue, TimeProfileYValue> >().Returns(_chartData);
var outputField = new PopulationAnalysisOutputField {
Dimension = DomainHelperForSpecs.MassConcentrationDimensionForSpecs()
};
_populationStatisticalAnalysis.Add(outputField);
A.CallTo(() => _dimensionRepository.MergedDimensionFor(A <NumericFieldContext> ._)).Returns(concentrationDimension);
}
private void checkDimensionCompatibilityFor(DataRepository observedData)
{
var allUsedDimensions = observedData.ObservationColumns().Select(x => x.Dimension)
.Distinct()
.ToList();
//use merge dimension for the output to ensure proper conversion between mass and amount
var availableDimensions = PopulationAnalysisChart.PopulationAnalysis.All <PopulationAnalysisOutputField>()
.Select(f => _dimensionRepository.MergedDimensionFor(new NumericFieldContext(f, PopulationDataCollector)))
.Distinct()
.ToList();
if (allUsedDimensions.Any(dimension => availableDimensions.Any(d => !d.CanConvertToUnit(dimension.DefaultUnitName))))
{
throw new PKSimException(PKSimConstants.Error.CannotAddObservedDataBecauseOfDimensionMismatch(observedData.Name,
availableDimensions.Select(x => x.DisplayName),
allUsedDimensions.Select(x => x.DisplayName)));
}
}
private ObservedCurveData mapFrom(DataColumn observedDataColumn, ObservedDataCurveOptions observedDataCurveOptions)
{
var yDimension = _dimensionRepository.MergedDimensionFor(observedDataColumn);
var observedCurve = createCurveData(observedDataColumn, observedDataCurveOptions, yDimension);
var errorColumn = errorColumnFor(observedDataColumn);
var baseGrid = observedDataColumn.BaseGrid;
baseGrid.Values.Each((value, i) =>
{
var observedDataYValue = new ObservedDataYValue
{
Mean = observedDataColumn[i],
ErrorType = observedCurve.ErrorType,
Error = errorColumn[i],
};
observedCurve.Add(new TimeProfileXValue(value), observedDataYValue);
});
return(observedCurve);
}
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);
}
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);
}
private IDimension createMergedDimensionFor(INumericValueField numericValueField)
{
return(_dimensionRepository.MergedDimensionFor(new NumericFieldContext(numericValueField, _populationDataCollector)));
}
