public ParseErrors ValidateDataSourceUnits(ColumnInfoCache columnInfos)
{
var errors = validateUnitsSupportedAndSameDimension(columnInfos);
errors.Add(validateErrorAgainstMeasurement(columnInfos));
return(errors);
}
public ParseErrors AddSheets(DataSheetCollection dataSheets, ColumnInfoCache columnInfos, string filter)
{
_importer.AddFromFile(_configuration.Format, dataSheets.Filter(filter), columnInfos, this);
if (NanSettings == null || !double.TryParse(NanSettings.Indicator, out var indicator))
{
indicator = double.NaN;
}
var errors = new ParseErrors();
foreach (var dataSet in DataSets.KeyValues)
{
if (NanSettings != null && NanSettings.Action == NanSettings.ActionType.Throw)
{
if (dataSet.Value.NanValuesExist(indicator))
{
errors.Add(dataSet.Value, new NaNParseErrorDescription());
}
}
else
{
dataSet.Value.ClearNan(indicator);
var emptyDataSets = dataSet.Value.Data.Where(parsedDataSet => parsedDataSet.Data.All(column => column.Value.Count == 0)).ToList();
if (emptyDataSets.Count == 0)
{
continue;
}
var emptyDataSetsNames = emptyDataSets.Select(d => string.Join(".", d.Description.Where(metaData => metaData.Value != null).Select(metaData => metaData.Value)));
errors.Add(dataSet.Value, new EmptyDataSetsParseErrorDescription(emptyDataSetsNames));
}
}
return(errors);
}
public void SetSettings(
IReadOnlyList <MetaDataCategory> metaDataCategories,
ColumnInfoCache columnInfos
)
{
_columnInfos = columnInfos;
_metaDataCategories = metaDataCategories;
}
public void SetSettings(IReadOnlyList <MetaDataCategory> metaDataCategories, ColumnInfoCache columnInfos,
DataImporterSettings dataImporterSettings)
{
_columnInfos = columnInfos;
_columnMappingPresenter.SetSettings(metaDataCategories, columnInfos);
_importerDataPresenter.SetSettings(metaDataCategories, columnInfos);
_dataImporterSettings = dataImporterSettings;
_metaDataCategories = metaDataCategories;
}
public double SetParameters(DataSheet rawDataSheet, ColumnInfoCache columnInfos, IReadOnlyList <MetaDataCategory> metaDataCategories)
{
if (NotCompatible(rawDataSheet, columnInfos))
{
return(0);
}
return(1 + setParameters(rawDataSheet, columnInfos, metaDataCategories));
}
protected override void Context()
{
base.Context();
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
Name = "Time", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
Name = "Concentration", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration", BaseGridName = "Time"
}
};
_columnInfos.ElementAt(1).SupportedDimensions.Add(DomainHelperForSpecs.ConcentrationDimensionForSpecs());
_columnInfos.ElementAt(2).SupportedDimensions.Add(DomainHelperForSpecs.ConcentrationDimensionForSpecs());
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory()
{
Name = "Time",
IsMandatory = true,
},
new MetaDataCategory()
{
Name = "Concentration",
IsMandatory = true
},
new MetaDataCategory()
{
DisplayName = "Error",
IsMandatory = false
},
new MetaDataCategory()
{
Name = "Molecule",
IsMandatory = false,
AllowsManualInput = true
}
};
_mappingParameterEditorPresenter = A.Fake <IMappingParameterEditorPresenter>();
_metaDataParameterEditorPresenter = A.Fake <IMetaDataParameterEditorPresenter>();
A.CallTo(() => _basicFormat.Parameters).Returns(_parameters);
A.CallTo(() => _importer.CheckWhetherAllDataColumnsAreMapped(A <ColumnInfoCache> .Ignored,
A <IEnumerable <DataFormatParameter> > .Ignored)).Returns(new MappingProblem()
{
MissingMapping = new List <string>(), MissingUnit = new List <string>()
});
sut = new ColumnMappingPresenter(_view, _importer, _mappingParameterEditorPresenter, _metaDataParameterEditorPresenter);
}
public Cache <string, IDataSet> GetDataSets(IDataFormat format, ColumnInfoCache columnInfos)
{
var dataSets = new Cache <string, IDataSet>();
foreach (var sheetKeyValue in _dataSheets.KeyValues)
{
var data = new DataSet();
data.AddData(format.Parse(sheetKeyValue.Value, columnInfos));
dataSets.Add(sheetKeyValue.Key, data);
}
return(dataSets);
}
public IEnumerable <ParsedDataSet> Parse(DataSheet dataSheet, ColumnInfoCache columnInfos)
{
var missingColumns = Parameters.Where(p => p.ComesFromColumn() && dataSheet.GetColumnDescription(p.ColumnName) == null).Select(p => p.ColumnName).ToList();
if (missingColumns.Any())
{
throw new MissingColumnException(dataSheet.SheetName, missingColumns);
}
var groupingCriteria =
Parameters
.Where(p => p.IsGroupingCriterion())
.Select(p => p.ColumnName);
return(buildDataSets(dataSheet, groupingCriteria, columnInfos));
}
protected override void Context()
{
sut = new MixColumnsDataFormat();
_rawDataSheet = A.Fake <DataSheet>();
A.CallTo(() => _rawDataSheet.GetHeaders()).ReturnsLazily(() => _headers);
A.CallTo(() => _rawDataSheet.GetColumnDescription(A <string> .Ignored)).Returns(new ColumnDescription(0)
{
Level = ColumnDescription.MeasurementLevel.Numeric
});
_columnInfos = new ColumnInfoCache
{
new ColumnInfo {
DisplayName = "Time", Name = "Time"
},
new ColumnInfo {
DisplayName = "Concentration", Name = "Concentration"
},
new ColumnInfo {
DisplayName = "Error", Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration"
}
};
_columnInfos["Time"].SupportedDimensions.Add(DimensionFactoryForSpecs.TimeDimension);
_columnInfos["Concentration"].SupportedDimensions.Add(DimensionFactoryForSpecs.ConcentrationDimension);
_columnInfos["Error"].SupportedDimensions.Add(DimensionFactoryForSpecs.ConcentrationDimension);
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory {
Name = "Organ"
},
new MetaDataCategory {
Name = "Compartment"
},
new MetaDataCategory {
Name = "Species"
},
new MetaDataCategory {
Name = "Dose"
},
new MetaDataCategory {
Name = "Molecule"
},
new MetaDataCategory {
Name = "Route"
}
};
}
public override void GlobalContext()
{
base.GlobalContext();
_fakedTimeDimension = A.Fake <IDimension>();
_fakedConcentrationDimension = A.Fake <IDimension>();
_fakedErrorDimension = A.Fake <IDimension>();
_fakedDimensionFactory = A.Fake <IDimensionFactory>();
_basicFormat = A.Fake <DataSheet>();
_container = A.Fake <IContainer>();
_dialogCreator = A.Fake <IDialogCreator>();
var dataFormat = A.Fake <IDataFormat>();
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
DisplayName = "Time"
},
new ColumnInfo()
{
DisplayName = "Concentration"
},
new ColumnInfo()
{
DisplayName = "Error"
}
};
_columnInfos["Time"].SupportedDimensions.Add(_fakedTimeDimension);
_columnInfos["Concentration"].SupportedDimensions.Add(_fakedConcentrationDimension);
_columnInfos["Error"].SupportedDimensions.Add(_fakedErrorDimension);
A.CallTo(() => dataFormat.SetParameters(_basicFormat, _columnInfos, null)).Returns(1);
A.CallTo(() => _container.ResolveAll <IDataFormat>()).Returns(new List <IDataFormat>()
{
dataFormat
});
_parser = A.Fake <IDataSourceFileParser>();
_dataRepositoryMapper = A.Fake <IDataSetToDataRepositoryMapper>();
A.CallTo(() => _container.Resolve <IDataSourceFileParser>()).Returns(_parser);
A.CallTo(() => _fakedTimeDimension.HasUnit("min")).Returns(true);
A.CallTo(() => _fakedConcentrationDimension.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _fakedErrorDimension.HasUnit("pmol/l")).Returns(true);
sut = new OSPSuite.Infrastructure.Import.Services.Importer(_container, _parser, _dataRepositoryMapper, _fakedDimensionFactory);
}
private double setParameters(DataSheet dataSheet, ColumnInfoCache columnInfos, IReadOnlyList <MetaDataCategory> metaDataCategories)
{
var keys = dataSheet.GetHeaders().ToList();
ExcelColumnNames = keys.ToList();
Parameters = new List <DataFormatParameter>();
var missingKeys = new List <string>();
var totalRank = 0.0;
ExtractQualifiedHeadings(keys, missingKeys, columnInfos, dataSheet, ref totalRank);
ExtractGeneralParameters(keys, dataSheet, metaDataCategories, ref totalRank);
ExtractNonQualifiedHeadings(keys, missingKeys, columnInfos, dataSheet, ref totalRank);
setSecondaryColumnUnit(columnInfos);
setDimensionsForMappings(columnInfos);
return(totalRank);
}
private void setDimensionsForMappings(ColumnInfoCache columnInfos)
{
foreach (var parameter in Parameters.OfType <MappingDataFormatParameter>())
{
var mappedColumn = parameter.MappedColumn;
if (mappedColumn?.Unit == null || mappedColumn?.Dimension != null)
{
continue;
}
var concreteColumnInfo = columnInfos[mappedColumn.Name];
//initial settings for fraction dimension
if (concreteColumnInfo.DefaultDimension?.Name == Constants.Dimension.FRACTION &&
mappedColumn.Unit.ColumnName.IsNullOrEmpty() &&
mappedColumn.Unit.SelectedUnit == UnitDescription.InvalidUnit)
{
mappedColumn.Dimension = concreteColumnInfo.DefaultDimension;
mappedColumn.Unit = new UnitDescription(mappedColumn.Dimension.DefaultUnitName);
continue;
}
if (!mappedColumn.Unit.ColumnName.IsNullOrEmpty())
{
mappedColumn.Dimension = null;
}
else
{
var supportedDimensions = concreteColumnInfo.SupportedDimensions;
var dimensionForUnit = supportedDimensions.FirstOrDefault(x => x.HasUnit(mappedColumn.Unit.SelectedUnit));
if (dimensionForUnit == null)
{
mappedColumn.Unit = new UnitDescription(UnitDescription.InvalidUnit);
}
else
{
mappedColumn.Dimension = dimensionForUnit;
}
}
}
}
public override (IReadOnlyList <DataRepository> DataRepositories, ImporterConfiguration Configuration) ImportDataSets(
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName
)
{
if (string.IsNullOrEmpty(dataFileName) || !System.IO.File.Exists(dataFileName))
{
return(Array.Empty <DataRepository>(), null);
}
var columnInfoCache = new ColumnInfoCache(columnInfos);
using (var importerModalPresenter = _applicationController.Start <IModalImporterPresenter>())
{
importerModalPresenter.SetCaption(dataImporterSettings.Caption);
return(importerModalPresenter.ImportDataSets(metaDataCategories, columnInfoCache, dataImporterSettings, dataFileName));
}
}
private void setSecondaryColumnUnit(ColumnInfoCache columnInfos)
{
var mappings = Parameters.OfType <MappingDataFormatParameter>();
foreach (var column in columnInfos.Where(c => !c.IsAuxiliary))
{
foreach (var relatedColumn in columnInfos.RelatedColumnsFrom(column.Name))
{
var relatedParameter = mappings.FirstOrDefault(p => p.ColumnName == relatedColumn.Name);
if (relatedParameter != null && (relatedParameter.MappedColumn.Unit == null || relatedParameter.MappedColumn.Unit.SelectedUnit == UnitDescription.InvalidUnit))
{
var mainParameter = mappings.FirstOrDefault(p => p.MappedColumn.Name == column.Name);
if (mainParameter != null)
{
relatedParameter.MappedColumn.Unit = mainParameter.MappedColumn.Unit;
}
}
}
}
}
public DataImporterTask(
IDataImporter dataImporter,
ICsvDynamicSeparatorSelector csvSeparatorSelector,
IDimensionFactory dimensionFactory,
IPKMLPersistor pkmlPersistor
)
{
_dataImporter = dataImporter;
_dimensionFactory = dimensionFactory;
_pkmlPersistor = pkmlPersistor;
_metaDataCategories = _dataImporter.DefaultMetaDataCategoriesForObservedData();
_dataImporterSettings = new DataImporterSettings
{
NameOfMetaDataHoldingMoleculeInformation = Constants.ObservedData.MOLECULE,
NameOfMetaDataHoldingMolecularWeightInformation = Constants.ObservedData.MOLECULAR_WEIGHT,
IgnoreSheetNamesAtImport = true
};
_columnInfos = _dataImporter.ColumnInfosForObservedData();
_columnInfoCache = new ColumnInfoCache(_columnInfos);
_csvSeparatorSelector = csvSeparatorSelector;
}
public override IReadOnlyList <DataRepository> ImportFromConfiguration(
ImporterConfiguration configuration,
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName)
{
if (string.IsNullOrEmpty(dataFileName) || !File.Exists(dataFileName))
{
throw new OSPSuiteException(Error.InvalidFile);
}
var columnInfoCache = new ColumnInfoCache(columnInfos);
var importedData = _importer.ImportFromConfiguration(configuration, columnInfoCache, dataFileName, metaDataCategories, dataImporterSettings);
if (importedData.MissingSheets.Count != 0)
{
_logger.AddWarning(Captions.Importer.SheetsNotFound(importedData.MissingSheets));
}
return(importedData.DataRepositories.Select(drm => drm.DataRepository).ToList());
}
protected override void Context()
{
base.Context();
sut = new ImporterDataPresenter(_view, _importer);
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
Name = "Time", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
Name = "Concentration", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration", BaseGridName = "Time"
}
};
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory()
{
Name = "Time", IsMandatory = true,
},
new MetaDataCategory()
{
Name = "Concentration", IsMandatory = true
},
new MetaDataCategory()
{
DisplayName = "Error", IsMandatory = false
}
};
sut.SetSettings(_metaDataCategories, _columnInfos);
}
public override IReadOnlyList <DataRepository> ImportFromConfiguration(
ImporterConfiguration configuration,
IReadOnlyList <MetaDataCategory> metaDataCategories,
IReadOnlyList <ColumnInfo> columnInfos,
DataImporterSettings dataImporterSettings,
string dataFileName
)
{
var columnInfoCache = new ColumnInfoCache(columnInfos);
if (string.IsNullOrEmpty(dataFileName) || !System.IO.File.Exists(dataFileName))
{
return(Enumerable.Empty <DataRepository>().ToList());
}
if (dataImporterSettings.PromptForConfirmation)
{
using (var importerModalPresenter = _applicationController.Start <IModalImporterPresenter>())
{
return(importerModalPresenter.ImportDataSets(metaDataCategories, columnInfoCache, dataImporterSettings, dataFileName, configuration));
}
}
try
{
var importedData = _importer.ImportFromConfiguration(configuration, columnInfoCache, dataFileName, metaDataCategories, dataImporterSettings);
if (importedData.MissingSheets.Count != 0)
{
_dialogCreator.MessageBoxError(SheetsNotFound(importedData.MissingSheets));
}
return(importedData.DataRepositories.Select(drm => drm.DataRepository).ToList());
}
catch (AbstractImporterException e)
{
_dialogCreator.MessageBoxError(e.Message);
return(new List <DataRepository>());
}
}
protected override void Context()
{
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
DisplayName = "Time", IsMandatory = true
},
new ColumnInfo()
{
DisplayName = "Concentration", IsMandatory = true
},
new ColumnInfo()
{
DisplayName = "Error", IsMandatory = false
}
};
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory()
{
Name = "Organ"
},
new MetaDataCategory()
{
Name = "Compartment"
},
new MetaDataCategory()
{
Name = "Species"
},
new MetaDataCategory()
{
Name = "Dose"
},
new MetaDataCategory()
{
Name = "Molecule"
},
new MetaDataCategory()
{
Name = "Route"
}
};
sut = new DataFormatNonmem();
_headersCache = new Cache <string, ColumnDescription>()
{
{
"Organ",
new ColumnDescription(0, new List <string>()
{
"PeripheralVenousBlood"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Compartment",
new ColumnDescription(1, new List <string>()
{
"Arterialized"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Species",
new ColumnDescription(2, new List <string>()
{
"Human"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Dose",
new ColumnDescription(3, new List <string>()
{
"75 [g] glucose"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Molecule",
new ColumnDescription(4, new List <string>()
{
"GLP-1_7-36 total", "Glucose", "Insuline", "GIP_total", "Glucagon"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Time",
new ColumnDescription(5, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Concentration",
new ColumnDescription(6, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Error",
new ColumnDescription(7, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Route",
new ColumnDescription(8, new List <string>()
{
"po"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Groupe Id",
new ColumnDescription(9, new List <string>()
{
"H", "T2DM"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Time_unit",
new ColumnDescription(10, new List <string>()
{
"min"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Concentration_unit",
new ColumnDescription(11, new List <string>()
{
"pmol/l"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Error_unit",
new ColumnDescription(12, new List <string>()
{
"pmol/l"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Concentration_lloq",
new ColumnDescription(13)
{
Level = ColumnDescription.MeasurementLevel.Numeric
}
}
};
_basicFormat = new TestDataSheet(_headersCache);
foreach (var molecule in _molecules)
{
foreach (var groupId in _groupIds)
{
for (var time = 0; time < 10; time++)
{
_basicFormat.AddRow(new List <string>()
{
"PeripheralVenousBlood",
"Arterialized",
"Human",
"75 [g] glucose",
molecule,
$"time",
"0",
"0",
"po",
groupId,
"min",
"pmol/l",
"pmol/l",
$"{0.01}"
});
}
}
}
}
protected bool NotCompatible(DataSheet dataSheet, ColumnInfoCache columnInfos)
{
return((dataSheet.GetHeaders()
.Select(dataSheet.GetColumnDescription)
.Count(header => header.Level == ColumnDescription.MeasurementLevel.Numeric)) < columnInfos.Count(ci => ci.IsMandatory));
}
//checks that the dimension of all the units coming from columns for error have the same dimension to the corresponding measurement
private ParseErrors validateErrorAgainstMeasurement(ColumnInfoCache columnInfos)
{
var errors = new ParseErrors();
foreach (var column in columnInfos.Where(c => !c.IsAuxiliary))
{
foreach (var relatedColumn in columnInfos.RelatedColumnsFrom(column.Name))
{
foreach (var dataSet in DataSets)
{
foreach (var set in dataSet.Data)
{
var measurementColumn = set.Data.FirstOrDefault(x => x.Key.ColumnInfo.Name == column.Name);
var errorColumn = set.Data.FirstOrDefault(x => x.Key.ColumnInfo.Name == relatedColumn.Name);
if (errorColumn.Key == null || errorColumn.Key.ErrorDeviation == Constants.STD_DEV_GEOMETRIC)
{
continue;
}
if (errorColumn.Value != null && measurementColumn.Value.Count != errorColumn.Value.Count)
{
errors.Add(dataSet, new MismatchingArrayLengthsParseErrorDescription());
continue;
}
var errorDimension = errorColumn.Key.Column.Dimension;
var measurementDimension = measurementColumn.Key.Column.Dimension;
if (errorDimension == null)
{
for (var i = 0; i < measurementColumn.Value.Count(); i++)
{
if (double.IsNaN(errorColumn.Value.ElementAt(i).Measurement))
{
continue;
}
var measurementSupportedDimension = column.SupportedDimensions.FirstOrDefault(x => x.HasUnit(measurementColumn.Value.ElementAt(i).Unit));
var errorSupportedDimension = column.SupportedDimensions.FirstOrDefault(x => x.HasUnit(errorColumn.Value.ElementAt(i).Unit));
if (measurementSupportedDimension != errorSupportedDimension)
{
errors.Add(dataSet, new ErrorUnitParseErrorDescription());
continue;
}
}
}
else
{
//if the dimension of the error is dimensionless (fe for geometric standard deviation)
//it is OK for it not to be of the smae dimension as the dimension of the measurement
if (errorDimension == Constants.Dimension.NO_DIMENSION ||
errorDimension.Name == Constants.Dimension.FRACTION)
{
continue;
}
if (measurementDimension != errorDimension)
{
errors.Add(dataSet, new ErrorUnitParseErrorDescription());
continue;
}
}
}
}
}
}
return(errors);
}
protected override void Context()
{
_fakedTimeDimension = A.Fake <IDimension>();
_fakedConcentrationDimension = A.Fake <IDimension>();
_fakedErrorDimension = A.Fake <IDimension>();
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
DisplayName = "Time", Name = "Time", IsMandatory = true
},
new ColumnInfo()
{
DisplayName = "Concentration", Name = "Concentration", IsMandatory = true
},
new ColumnInfo()
{
DisplayName = "Error", Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration"
}
};
_columnInfos["Time"].SupportedDimensions.Add(_fakedTimeDimension);
_columnInfos["Concentration"].SupportedDimensions.Add(_fakedConcentrationDimension);
_columnInfos["Error"].SupportedDimensions.Add(_fakedErrorDimension);
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory()
{
Name = "Organ"
},
new MetaDataCategory()
{
Name = "Compartment"
},
new MetaDataCategory()
{
Name = "Species"
},
new MetaDataCategory()
{
Name = "Dose"
},
new MetaDataCategory()
{
Name = "Molecule"
},
new MetaDataCategory()
{
Name = "Route"
}
};
A.CallTo(() => _fakedTimeDimension.HasUnit("min")).Returns(true);
A.CallTo(() => _fakedConcentrationDimension.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _fakedErrorDimension.HasUnit("pmol/l")).Returns(true);
sut = new DataFormatHeadersWithUnits();
_basicFormat = new TestDataSheet
(
new Cache <string, ColumnDescription>()
{
{
"Organ",
new ColumnDescription(0, new List <string>()
{
"PeripheralVenousBlood"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Compartment",
new ColumnDescription(1, new List <string>()
{
"Arterialized"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Species",
new ColumnDescription(2, new List <string>()
{
"Human"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Dose",
new ColumnDescription(3, new List <string>()
{
"75 [g] glucose"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Molecule",
new ColumnDescription(4, new List <string>()
{
"GLP-1_7-36 total", "Glucose", "Insuline", "GIP_total", "Glucagon"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Time [min]",
new ColumnDescription(5, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Concentration (molar) [pmol/l]",
new ColumnDescription(6, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Error [pmol/l]",
new ColumnDescription(7, null, ColumnDescription.MeasurementLevel.Numeric)
},
{
"Route",
new ColumnDescription(8, new List <string>()
{
"po"
}, ColumnDescription.MeasurementLevel.Discrete)
},
{
"Groupe Id",
new ColumnDescription(9, new List <string>()
{
"H", "T2DM"
}, ColumnDescription.MeasurementLevel.Discrete)
}
}
);
}
protected override void Context()
{
_fakedTimeDimension = A.Fake <IDimension>();
_fakedConcentrationDimensionMolar = A.Fake <IDimension>();
_fakedConcentrationDimensionMass = A.Fake <IDimension>();
_fakedErrorDimension = A.Fake <IDimension>();
_fakedImporter = A.Fake <IImporter>();
_fakeDataSet = new DataSet();
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
DisplayName = "Time", Name = "Time"
},
new ColumnInfo()
{
DisplayName = "Concentration", Name = "Concentration"
},
new ColumnInfo()
{
DisplayName = "Error", Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration"
}
};
_columnInfos["Time"].SupportedDimensions.Add(_fakedTimeDimension);
_columnInfos["Concentration"].SupportedDimensions.Add(_fakedConcentrationDimensionMolar);
_columnInfos["Concentration"].SupportedDimensions.Add(_fakedConcentrationDimensionMass);
_columnInfos["Error"].SupportedDimensions.Add(_fakedErrorDimension);
_columnInfos["Error"].SupportedDimensions.Add(_fakedConcentrationDimensionMass);
var parsedData = new Dictionary <ExtendedColumn, IList <SimulationPoint> >()
{
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Time",
Unit = new UnitDescription("s")
},
ColumnInfo = _columnInfos["Time"]
},
new List <SimulationPoint>()
{
new SimulationPoint()
{
Unit = "s",
Measurement = 0,
Lloq = double.NaN
},
new SimulationPoint()
{
Unit = "s",
Measurement = 1,
Lloq = double.NaN
},
new SimulationPoint()
{
Unit = "s",
Measurement = 2,
Lloq = double.NaN
}
}
},
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Concentration",
Unit = new UnitDescription("pmol/l")
},
ColumnInfo = _columnInfos["Concentration"]
},
new List <SimulationPoint>()
{
new SimulationPoint()
{
Unit = "pmol/l",
Measurement = 10,
Lloq = 1
},
new SimulationPoint()
{
Unit = "pmol/l",
Measurement = 0.1,
Lloq = 1
},
new SimulationPoint()
{
Unit = "pmol/l",
Measurement = double.NaN,
Lloq = 1
}
}
},
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Error",
Unit = new UnitDescription("")
},
ColumnInfo = _columnInfos["Error"]
},
new List <SimulationPoint>()
{
new SimulationPoint()
{
Unit = "",
Measurement = 10,
Lloq = 1
},
new SimulationPoint()
{
Unit = "",
Measurement = 0.1,
Lloq = 1
},
new SimulationPoint()
{
Unit = "",
Measurement = double.NaN,
Lloq = 1
}
}
}
};
A.CallTo(() => _fakedTimeDimension.HasUnit("min")).Returns(true);
A.CallTo(() => _fakedTimeDimension.HasUnit("s")).Returns(true);
A.CallTo(() => _fakedConcentrationDimensionMolar.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _fakedConcentrationDimensionMass.HasUnit("ng/ml")).Returns(true);
A.CallTo(() => _fakedErrorDimension.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _fakedConcentrationDimensionMolar.FindUnit("no unit", true)).Returns(null);
A.CallTo(() => _fakedConcentrationDimensionMass.FindUnit("no unit", true)).Returns(null);
A.CallTo(() => _fakedErrorDimension.FindUnit("no unit", true)).Returns(null);
A.CallTo(() => _fakedConcentrationDimensionMolar.FindUnit("ng/ml", true)).Returns(null);
A.CallTo(() => _fakedConcentrationDimensionMass.FindUnit("pmol/l", true)).Returns(null);
_fakeDataSet.AddData(new List <ParsedDataSet>()
{
new ParsedDataSet(new List <string>(), A.Fake <DataSheet>(), new List <UnformattedRow>(),
parsedData)
});
sut = new DataSource(_fakedImporter);
sut.DataSets.Add("sheet1", _fakeDataSet);
}
protected override void Context()
{
base.Context();
_columnInfos = new ColumnInfoCache
{
new ColumnInfo()
{
DisplayName = "Time", Name = "Time", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
DisplayName = "Concentration", Name = "Concentration", IsMandatory = true, BaseGridName = "Time"
},
new ColumnInfo()
{
DisplayName = "Error", Name = "Error", IsMandatory = false, RelatedColumnOf = "Concentration", BaseGridName = "Time"
}
};
var parsedData = new Dictionary <ExtendedColumn, IList <SimulationPoint> >()
{
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Time",
Unit = new UnitDescription("s")
},
ColumnInfo = _columnInfos["Time"]
},
new List <SimulationPoint>()
{
}
},
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Concentration",
Unit = new UnitDescription("mol")
},
ColumnInfo = _columnInfos["Concentration"]
},
new List <SimulationPoint>()
{
}
},
{
new ExtendedColumn()
{
Column = new Column()
{
Name = "Error",
Unit = new UnitDescription("")
},
ColumnInfo = _columnInfos["Error"]
},
new List <SimulationPoint>()
{
}
}
};
var dataSet = new DataSet();
dataSet.AddData(new List <ParsedDataSet>()
{
{ new ParsedDataSet(new List <string>(), A.Fake <DataSheet>(), new List <UnformattedRow>(), parsedData) }
});
_dimensionFactory = A.Fake <IDimensionFactory>();
var fractionDimension = A.Fake <IDimension>();
A.CallTo(() => fractionDimension.Name).Returns(Constants.Dimension.FRACTION);
var otherDimension = A.Fake <IDimension>();
A.CallTo(() => otherDimension.Name).Returns("mol");
A.CallTo(() => _dimensionFactory.DimensionForUnit("")).Returns(fractionDimension);
A.CallTo(() => _dimensionFactory.DimensionForUnit("mol")).Returns(otherDimension);
sut.DataSets.Clear();
sut.DataSets.Add("sheet1", dataSet);
}
public override void GlobalContext()
{
base.GlobalContext();
_fakedTimeDimension = A.Fake <IDimension>();
_fakedConcentrationDimension = A.Fake <IDimension>();
_fakedErrorDimension = A.Fake <IDimension>();
_container = A.Fake <IContainer>();
_dialogCreator = A.Fake <IDialogCreator>();
_fakedDimensionFactory = A.Fake <IDimensionFactory>();
var dataFormat = A.Fake <IDataFormat>();
_columnInfos = new ColumnInfoCache()
{
new ColumnInfo()
{
DisplayName = "Time"
},
new ColumnInfo()
{
DisplayName = "Concentration"
},
new ColumnInfo()
{
DisplayName = "Error"
}
};
_metaDataCategories = new List <MetaDataCategory>()
{
new MetaDataCategory()
{
Name = "Organ"
},
new MetaDataCategory()
{
Name = "Compartment"
},
new MetaDataCategory()
{
Name = "Species"
},
new MetaDataCategory()
{
Name = "Dose"
},
new MetaDataCategory()
{
Name = "Molecule"
},
new MetaDataCategory()
{
Name = "Route"
}
};
_columnInfos["Time"].SupportedDimensions.Add(_fakedTimeDimension);
_columnInfos["Concentration"].SupportedDimensions.Add(_fakedConcentrationDimension);
_columnInfos["Error"].SupportedDimensions.Add(_fakedErrorDimension);
A.CallTo(() => _fakedTimeDimension.HasUnit("min")).Returns(true);
A.CallTo(() => _fakedConcentrationDimension.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _fakedErrorDimension.HasUnit("pmol/l")).Returns(true);
A.CallTo(() => _container.ResolveAll <IDataFormat>()).Returns(new List <IDataFormat>()
{
new DataFormatHeadersWithUnits(), new DataFormatNonmem(), new MixColumnsDataFormat()
});
_parser = A.Fake <IDataSourceFileParser>();
_dataRepositoryMapper = A.Fake <IDataSetToDataRepositoryMapper>();
A.CallTo(() => _container.Resolve <IDataSourceFileParser>()).Returns(_parser);
sut = new OSPSuite.Infrastructure.Import.Services.Importer(_container, _parser, _dataRepositoryMapper, _fakedDimensionFactory);
}
