private void addWarningsTo(PKAnalysis pkAnalysis, GlobalPKAnalysis globalPKAnalysis, string moleculeName)
{
if (globalPKAnalysis == null)
{
return;
}
addFractionAbsorbedWarningTo(pkAnalysis, globalPKAnalysis, moleculeName);
}
protected override void Context()
{
base.Context();
_simulation = new IndividualSimulation {
DataRepository = new DataRepository()
};
_baseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs())
{
Values = new[] { 10f, 20f, 30f }
};
_dataColumn1 = new DataColumn("C1", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), _baseGrid)
{
DataInfo = { Origin = ColumnOrigins.Calculation },
QuantityInfo = { Path = new[] { "C1", "Concentration" } },
Values = new[] { 11f, 21f, 31f }
};
_dataColumn2 = new DataColumn("C2", DomainHelperForSpecs.ConcentrationDimensionForSpecs(), _baseGrid)
{
DataInfo = { Origin = ColumnOrigins.Calculation },
QuantityInfo = { Path = new[] { "C2", "Concentration" } },
Values = new[] { 12f, 22f, 32f }
};
_simulation.DataRepository.Add(_dataColumn1);
_simulation.DataRepository.Add(_dataColumn2);
//Setup global PK analysis
_globalPKAnalysis = new GlobalPKAnalysis();
var c1Container = new Container().WithName("C1");
c1Container.Add(DomainHelperForSpecs.ConstantParameterWithValue(0.5).WithName(CoreConstants.PKAnalysis.FractionAbsorbed));
var c2Container = new Container().WithName("C2");
c2Container.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.PKAnalysis.FractionAbsorbed));
_globalPKAnalysis.Add(c1Container);
_globalPKAnalysis.Add(c2Container);
_pkC1 = new PKAnalysis
{
DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(Constants.PKParameters.MRT),
DomainHelperForSpecs.ConstantParameterWithValue(2).WithName(Constants.PKParameters.Tmax)
};
_pkC2 = new PKAnalysis
{
DomainHelperForSpecs.ConstantParameterWithValue(3).WithName(Constants.PKParameters.MRT),
DomainHelperForSpecs.ConstantParameterWithValue(4).WithName(Constants.PKParameters.Tmax)
};
A.CallTo(() => _pkMapper.MapFrom(_dataColumn1, A <PKValues> ._, A <PKParameterMode> ._, "C1")).Returns(_pkC1);
A.CallTo(() => _pkMapper.MapFrom(_dataColumn2, A <PKValues> ._, A <PKParameterMode> ._, "C2")).Returns(_pkC2);
_defaultNumberOfRules = DomainHelperForSpecs.ConstantParameterWithValue(3).Rules.Count;
}
public void ExportToExcel(IEnumerable <DataColumn> dataColumns, GlobalPKAnalysis globalPKAnalysis, DataTable pkAnalysisDataTable, IEnumerable <Simulation> simulations)
{
var allSimulations = simulations.ToList();
string defaultFileName = allSimulations.Count == 1 ? allSimulations[0].Name : string.Empty;
var fileName = _dialogCreator.AskForFileToSave(PKSimConstants.UI.ExportPKAnalysesToExcelTitle, Constants.Filter.EXCEL_SAVE_FILE_FILTER, Constants.DirectoryKey.REPORT, defaultFileName);
if (string.IsNullOrEmpty(fileName))
{
return;
}
var allDataTables = ExportToDataTable(dataColumns, globalPKAnalysis, pkAnalysisDataTable, allSimulations);
_dataRepositoryTask.ExportToExcel(allDataTables, fileName, launchExcel: true);
}
public static GlobalPKAnalysis GenerateGlobalPKAnalysis(string drugName)
{
var globalPKAnalysis = new GlobalPKAnalysis();
var container = new Container().WithName(drugName);
globalPKAnalysis.Add(container);
container.AddChildren(
new PKSimParameter {
Name = Constants.PKParameters.Vd, Value = 0.0
},
new PKSimParameter {
Name = Constants.PKParameters.Vss, Value = 0.0
});
return(globalPKAnalysis);
}
protected override void Context()
{
_view = A.Fake <IGlobalPKAnalysisView>();
_globalPKAnalysisTask = A.Fake <IGlobalPKAnalysisTask>();
var globalPKAnalysisDTOMapper = A.Fake <IGlobalPKAnalysisToGlobalPKAnalysisDTOMapper>();
var heavyWorkManager = A.Fake <IHeavyWorkManager>();
var representationInfoRepository = A.Fake <IRepresentationInfoRepository>();
_presenterSettingsTask = A.Fake <IPresentationSettingsTask>();
sut = new GlobalPKAnalysisPresenter(_view, _globalPKAnalysisTask, globalPKAnalysisDTOMapper, heavyWorkManager, representationInfoRepository, _presenterSettingsTask);
_simulations = new List <Simulation>();
_compoundName = "DRUG";
_globalPKAnalysis = PKAnalysisHelperForSpecs.GenerateGlobalPKAnalysis(_compoundName);
A.CallTo(() => _globalPKAnalysisTask.CalculateGlobalPKAnalysisFor(_simulations)).Returns(_globalPKAnalysis);
}
private void addFractionAbsorbedWarningTo(PKAnalysis pkAnalysis, GlobalPKAnalysis globalPKAnalysis, string moleculeName)
{
var fractionAbsorbed = globalPKAnalysis.PKParameter(moleculeName, CoreConstants.PKAnalysis.FractionAbsorbed);
if (fractionAbsorbed == null)
{
return;
}
if (ValueComparer.AreValuesEqual(fractionAbsorbed.Value, 1, CoreConstants.DOUBLE_RELATIVE_EPSILON))
{
return;
}
addWarningsTo(pkAnalysis, PKSimConstants.Warning.FractionAbsorbedSmallerThanOne, CoreConstants.PKAnalysis.AllParametersInfluencedByFractionAbsorbed);
}
public DataTable MapFrom(GlobalPKAnalysis globalPKAnalysis, bool addMetaData = false)
{
var dataTable = new DataTable(PKSimConstants.UI.GlobalPKAnalyses);
dataTable.AddColumn(PKSimConstants.PKAnalysis.ParameterDisplayName);
dataTable.AddColumn(PKSimConstants.PKAnalysis.Compound);
dataTable.AddColumn <double>(PKSimConstants.PKAnalysis.Value);
dataTable.AddColumn(PKSimConstants.PKAnalysis.Unit);
if (addMetaData)
{
dataTable.AddColumn(PKSimConstants.PKAnalysis.ParameterName);
dataTable.AddColumn(PKSimConstants.PKAnalysis.Description);
dataTable.AddColumn(PKSimConstants.PKAnalysis.Warning);
}
foreach (var parameterName in globalPKAnalysis.AllPKParameterNames)
{
foreach (var compoundName in globalPKAnalysis.CompoundNames)
{
var parameter = globalPKAnalysis.PKParameter(compoundName, parameterName);
if (parameter == null)
{
continue;
}
var info = _representationInfoRepository.InfoFor(parameter);
var row = dataTable.NewRow();
row[PKSimConstants.PKAnalysis.ParameterDisplayName] = info.DisplayName;
row[PKSimConstants.PKAnalysis.Compound] = compoundName;
row[PKSimConstants.PKAnalysis.Value] = parameter.ValueInDisplayUnit;
row[PKSimConstants.PKAnalysis.Unit] = parameter.DisplayUnit;
if (addMetaData)
{
row[PKSimConstants.PKAnalysis.ParameterName] = parameter.Name;
row[PKSimConstants.PKAnalysis.Warning] = parameter.Validate().Message;
row[PKSimConstants.PKAnalysis.Description] = info.Description;
}
dataTable.Rows.Add(row);
}
}
return(dataTable);
}
protected override void Context()
{
base.Context();
_fileName = "file";
_dataTable1 = new DataTable();
_dataTable2 = new DataTable();
var baseGrid = new BaseGrid("time", A.Fake <IDimension>());
_col1 = new DataColumnn("col1", A.Fake <IDimension>(), baseGrid);
_col2 = new DataColumnn("col2", A.Fake <IDimension>(), baseGrid);
_global = new GlobalPKAnalysis();
_sim1 = A.Fake <Simulation>().WithName("Sim");
A.CallTo(_dialogCreator).WithReturnType <string>().Returns(_fileName);
A.CallTo(() => _dataRepositoryTask.ToDataTable(A <IEnumerable <DataColumnn> > ._, A <Func <DataColumnn, string> > ._, false)).Returns(new[] { _dataTable1, _dataTable2 });
A.CallTo(() => _dataRepositoryTask.ExportToExcel(A <IEnumerable <DataTable> > ._, _fileName, true))
.Invokes(x => _dataTables = x.GetArgument <IEnumerable <DataTable> >(0));
}
protected override void Context()
{
_representationInfoRepository = A.Fake <IRepresentationInfoRepository>();
sut = new GlobalPKAnalysisToDataTableMapper(_representationInfoRepository);
_globalPKAnalysis = new GlobalPKAnalysis();
_compound1 = new Container().WithName("Drug");
_compound2 = new Container().WithName("Inhibitor");
_globalPKAnalysis.Add(_compound1);
_globalPKAnalysis.Add(_compound2);
_compound1.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P1"));
_compound1.Add(DomainHelperForSpecs.ConstantParameterWithValue(2).WithName("P2"));
_compound2.Add(DomainHelperForSpecs.ConstantParameterWithValue(3).WithName("P1"));
_compound2.Add(DomainHelperForSpecs.ConstantParameterWithValue(4).WithName("P3"));
A.CallTo(() => _representationInfoRepository.InfoFor(A <IParameter> ._))
.ReturnsLazily(x => new RepresentationInfo {
DisplayName = "Display for " + x.GetArgument <IParameter>(0).Name
});
}
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));
}
public IEnumerable <IndividualPKAnalysis> CalculateFor(IReadOnlyList <Simulation> simulations, IEnumerable <DataColumn> dataColumns, GlobalPKAnalysis globalPKAnalysis = null)
{
var allPKAnalysis = new List <IndividualPKAnalysis>();
var allColumns = dataColumns.ToList();
foreach (var simulation in simulations)
{
var columnsByMolecules = allColumns.BelongingTo(simulation).GroupBy(x => x.MoleculeName());
foreach (var columnsByMolecule in columnsByMolecules)
{
var moleculeName = columnsByMolecule.Key;
var options = _pkCalculationOptionsFactory.CreateFor(simulation, moleculeName);
allPKAnalysis.AddRange(columnsByMolecule.Select(c => calculatePKFor(c, moleculeName, options, globalPKAnalysis)));
}
}
//last but not least, add observed data that do not belong to any simulation
allPKAnalysis.AddRange(allColumns.Where(x => x.IsObservation())
.Select(observedDataColumn =>
{
var moleculeName = observedDataColumn.Repository.ExtendedPropertyValueFor(Constants.ObservedData.MOLECULE);
var observedDataPKOptions = _pkCalculationOptionsFactory.CreateForObservedData(simulations, moleculeName);
return(calculatePKFor(observedDataColumn, moleculeName, observedDataPKOptions));
}));
return(allPKAnalysis);
}
private void showPKAnalysis()
{
GlobalPKAnalysis = _globalPKAnalysisTask.CalculateGlobalPKAnalysisFor(_simulations);
updateView();
}
protected override void Because()
{
_result = sut.CalculateGlobalPKAnalysisFor(new[] { _simulation });
}
public GlobalPKAnalysisDTO MapFrom(GlobalPKAnalysis globalPKAnalysis)
{
return(new GlobalPKAnalysisDTO(_dataTableMapper.MapFrom(globalPKAnalysis, addMetaData: true)));
}
private void updateDisplayUnits(GlobalPKAnalysis globalPKAnalysis, IPresentationSettings presentationSettings)
{
UpdateParameterDisplayUnit(globalPKAnalysis.AllPKParameters, presentationSettings);
}
public IEnumerable <DataTable> ExportToDataTable(IEnumerable <DataColumn> dataColumns, GlobalPKAnalysis globalPKAnalysis, DataTable dataTable, IEnumerable <Simulation> simulations)
{
var allDataTables = new List <DataTable>();
var allSimulations = simulations.ToList();
if (allSimulations.Any())
{
string ColumnNameRetriever(DataColumn dataColumn) => _quantityDisplayPathMapper.DisplayPathAsStringFor(simulationForColumn(dataColumn, allSimulations), dataColumn);
allDataTables.AddRange(_dataRepositoryTask.ToDataTable(dataColumns, ColumnNameRetriever, _dimensionFactory.MergedDimensionFor));
}
allDataTables.Add(_globalPKAnalysisToDataTableMapper.MapFrom(globalPKAnalysis));
allDataTables.Add(dataTable);
return(allDataTables);
}
public GlobalPKAnalysis CalculateGlobalPKAnalysisFor(IEnumerable <Simulation> simulations)
{
var globalPKAnalysis = new GlobalPKAnalysis();
var allSimulations = simulations.ToList();
if (allSimulations.Count != 1)
{
return(globalPKAnalysis);
}
var simulation = allSimulations[0] as IndividualSimulation;
if (simulation == null)
{
return(globalPKAnalysis);
}
//one container per compound
foreach (var compound in simulation.Compounds)
{
var compoundName = compound.Name;
var container = new Container().WithName(compoundName);
globalPKAnalysis.Add(container);
var peripheralVenousBloodCurve = simulation.DataRepository.PeripheralVenousBloodColumn(compoundName);
var venousBloodCurve = simulation.DataRepository.VenousBloodColumn(compoundName);
if (peripheralVenousBloodCurve == null || venousBloodCurve == null)
{
continue;
}
var options = _pkCalculationOptionsFactory.CreateFor(simulation, compoundName);
var venousBloodPlasmaPK = _pkAnalysisTask.CalculatePK(venousBloodCurve, options);
var aucIV = simulation.AucIVFor(compoundName);
var aucDDI = simulation.AucDDIFor(compoundName);
var cmaxDDI = simulation.CmaxDDIFor(compoundName);
var bioAvailability = createRatioParameter(CoreConstants.PKAnalysis.Bioavailability, venousBloodPlasmaPK[Constants.PKParameters.AUC_inf], aucIV, Constants.Dimension.DIMENSIONLESS);
var bioAvailabilityValue = bioAvailability.Value;
var bloodCurveForPKAnalysis = bloodCurveForSpecies(peripheralVenousBloodCurve, venousBloodCurve, simulation.Individual);
var bloodPlasmaPK = _pkAnalysisTask.CalculatePK(bloodCurveForPKAnalysis, options);
var applicationType = applicationTypeFor(simulation, compound);
var aucRatio = createRatioParameter(CoreConstants.PKAnalysis.AUCRatio, bloodPlasmaPK[pkParameterNameForAUCRatio(applicationType)], aucDDI, Constants.Dimension.DIMENSIONLESS);
var cmaxRatio = createRatioParameter(CoreConstants.PKAnalysis.C_maxRatio, bloodPlasmaPK[pkParameterNameForCmaxRatio(applicationType)], cmaxDDI, Constants.Dimension.DIMENSIONLESS);
var vssPlasma = createParameter(CoreConstants.PKAnalysis.VssPlasma, bloodPlasmaPK[Constants.PKParameters.Vss], CoreConstants.Dimension.VolumePerBodyWeight);
var vssPlasmaOverF = createParameter(CoreConstants.PKAnalysis.VssPlasmaOverF, bloodPlasmaPK[Constants.PKParameters.Vss], CoreConstants.Dimension.VolumePerBodyWeight);
var vdPlasma = createParameter(CoreConstants.PKAnalysis.VdPlasma, bloodPlasmaPK[Constants.PKParameters.Vd], CoreConstants.Dimension.VolumePerBodyWeight);
var vdPlasmaOverF = createParameter(CoreConstants.PKAnalysis.VdPlasmaOverF, bloodPlasmaPK[Constants.PKParameters.Vd], CoreConstants.Dimension.VolumePerBodyWeight);
var vssPhysChem = createParameter(CoreConstants.PKAnalysis.VssPhysChem, calculateVSSPhysChemFor(simulation, compoundName), CoreConstants.Dimension.VolumePerBodyWeight);
var totalPlasmaCL = createParameter(CoreConstants.PKAnalysis.TotalPlasmaCL, bloodPlasmaPK[Constants.PKParameters.CL], CoreConstants.Dimension.FlowPerWeight);
var totalPlasmaCLOverF = createParameter(CoreConstants.PKAnalysis.TotalPlasmaCLOverF, bloodPlasmaPK[Constants.PKParameters.CL], CoreConstants.Dimension.FlowPerWeight);
if (_interactionTask.HasInteractionInvolving(compound, simulation))
{
container.AddChildren(aucRatio, cmaxRatio);
}
var fractionAbsorbed = fractionAbsorbedFor(simulation, compoundName);
//multiple application or no application? in that case, only show fraction absorbed for oral
if (applicationType != ApplicationType.Single)
{
if (isMultipleOral(simulation, compound))
{
container.Add(fractionAbsorbed);
}
continue;
}
var schemaItem = singleDosingItem(simulation, compound);
var pkValues = new List <IParameter>();
var bioAvailabilityCalculated = !double.IsNaN(bioAvailabilityValue);
if (isIntravenous(schemaItem))
{
container.AddChildren(vssPlasma, vdPlasma, vssPhysChem, totalPlasmaCL);
continue;
}
var fractionAbsorbedWarningParameters = new List <IParameter>();
if (bioAvailabilityCalculated)
{
vssPlasma.Value *= bioAvailabilityValue;
vdPlasma.Value *= bioAvailabilityValue;
totalPlasmaCL.Value *= bioAvailabilityValue;
fractionAbsorbedWarningParameters.AddRange(new[] { vssPlasma, vdPlasma });
pkValues.AddRange(new[] { vssPlasma, vdPlasma, totalPlasmaCL, bioAvailability });
}
else
{
fractionAbsorbedWarningParameters.AddRange(new[] { vssPlasmaOverF, vdPlasmaOverF });
pkValues.AddRange(new[] { vssPlasmaOverF, vdPlasmaOverF, totalPlasmaCLOverF, bioAvailability });
}
if (isOral(schemaItem))
{
fractionAbsorbed.Rules.Add(fractionAbsorbedRule);
pkValues.Add(fractionAbsorbed);
if (bioAvailability.Value > fractionAbsorbed.Value)
{
bioAvailability.Rules.Add(bioAvailabilityRule);
}
addFractionAbsorvedWarningTo(fractionAbsorbed, fractionAbsorbedWarningParameters);
}
container.AddChildren(pkValues);
}
return(globalPKAnalysis);
}
public IEnumerable <DataTable> ExportToDataTable(IEnumerable <DataColumn> dataColumns, GlobalPKAnalysis globalPKAnalysis, DataTable dataTable, IEnumerable <Simulation> simulations)
{
var allDataTables = new List <DataTable>();
var allSimulations = simulations.ToList();
if (allSimulations.Any())
{
allDataTables.AddRange(_dataRepositoryTask.ToDataTable(dataColumns, x => _quantityDisplayPathMapper.DisplayPathAsStringFor(simulationForColumn(x, allSimulations), x)));
}
allDataTables.Add(_globalPKAnalysisToDataTableMapper.MapFrom(globalPKAnalysis));
allDataTables.Add(dataTable);
return(allDataTables);
}
