public override async Task <ModelSchema> MapToModel(SnapshotSchema snapshot, SnapshotContext snapshotContext)
{
var schema = _schemaFactory.Create();
MapSnapshotPropertiesToModel(snapshot, schema);
await UpdateParametersFromSnapshot(snapshot, schema, snapshotContext, PKSimConstants.ObjectTypes.Schema);
var schemaItems = await _schemaItemMapper.MapToModels(snapshot.SchemaItems, snapshotContext);
schemaItems?.Each(schema.AddSchemaItem);
return(schema);
}
public override async Task <ModelProject> MapToModel(SnapshotProject snapshot, ProjectContext projectContext)
{
_logger.AddDebug($"Loading project '{snapshot.Name}' from snapshot...", snapshot.Name);
var project = new ModelProject
{
Name = snapshot.Name,
Description = snapshot.Description,
Creation = _creationMetaDataFactory.Create()
};
//The entry point of our context structure.
var snapshotContext = new SnapshotContext(project, snapshot.Version);
project.Creation.InternalVersion = snapshot.Version;
project.Creation.Version = ProjectVersions.FindBy(snapshot.Version)?.VersionDisplay;
await allBuildingBlocksFrom(snapshot, snapshotContext);
var observedData = await observedDataFrom(snapshot.ObservedData, snapshotContext);
observedData?.Each(repository => addObservedDataToProject(project, repository));
var allSimulations = await allSimulationsFrom(project, projectContext, snapshot.Simulations, snapshotContext);
allSimulations?.Each(simulation => addSimulationToProject(project, simulation));
var allSimulationComparisons = await allSimulationComparisonsFrom(snapshot.SimulationComparisons, snapshotContext);
allSimulationComparisons?.Each(comparison => addComparisonToProject(project, comparison));
var allParameterIdentifications = await allParameterIdentificationsFrom(snapshot.ParameterIdentifications, snapshotContext);
allParameterIdentifications?.Each(parameterIdentification => addParameterIdentificationToProject(project, parameterIdentification));
var allQualificationPlans = await allQualificationPlansFrom(snapshot.QualificationPlans, snapshotContext);
allQualificationPlans?.Each(qualificationPlan => addQualificationPlanToProject(project, qualificationPlan));
//Map all classifications once project is loaded
await updateProjectClassifications(snapshot, snapshotContext);
return(project);
}
private Task updateProjectClassifications(SnapshotProject snapshot, SnapshotContext snapshotContext)
{
var project = snapshotContext.Project;
var tasks = new[]
{
_classificationSnapshotTask.UpdateProjectClassifications <ClassifiableObservedData, ModelDataRepository>(
snapshot.ObservedDataClassifications, snapshotContext, project.AllObservedData),
_classificationSnapshotTask.UpdateProjectClassifications <ClassifiableSimulation, Model.Simulation>(snapshot.SimulationClassifications,
snapshotContext, project.All <Model.Simulation>()),
_classificationSnapshotTask.UpdateProjectClassifications <ClassifiableComparison, ISimulationComparison>(
snapshot.SimulationComparisonClassifications, snapshotContext, project.AllSimulationComparisons),
_classificationSnapshotTask.UpdateProjectClassifications <ClassifiableParameterIdentification, ModelParameterIdentification>(
snapshot.ParameterIdentificationClassifications, snapshotContext, project.AllParameterIdentifications),
_classificationSnapshotTask.UpdateProjectClassifications <ClassifiableQualificationPlan, Model.QualificationPlan>(
snapshot.QualificationPlanClassifications, snapshotContext, project.AllQualificationPlans),
};
return(Task.WhenAll(tasks));
}
private async Task allBuildingBlocksFrom(SnapshotProject snapshot, SnapshotContext snapshotContext)
{
//Expression profile needs to be added first
var expressionProfiles = await mapSnapshotToBuildingBlocks <Model.ExpressionProfile, ExpressionProfile>(snapshot.ExpressionProfiles, snapshotContext);
expressionProfiles.Each(snapshotContext.Project.AddBuildingBlock);
//other can be loaded independently
var buildingBlocks = new List <IPKSimBuildingBlock>();
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.Individual, Individual>(snapshot.Individuals, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.Compound, Compound>(snapshot.Compounds, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <PKSimEvent, Event>(snapshot.Events, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.Formulation, Formulation>(snapshot.Formulations, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.Protocol, Protocol>(snapshot.Protocols, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.Population, Population>(snapshot.Populations, snapshotContext));
buildingBlocks.AddRange(await mapSnapshotToBuildingBlocks <Model.ObserverSet, ObserverSet>(snapshot.ObserverSets, snapshotContext));
buildingBlocks.Each(snapshotContext.Project.AddBuildingBlock);
}
private async Task addProcessToProcessSelection(CompoundProcessesSelection compoundProcessesSelection, CompoundProcessSelection snapshotCompoundProcessSelection, Model.CompoundProcess process, SnapshotContext snapshotContext)
{
var processSelectionGroup = selectionGroupFor(compoundProcessesSelection, process);
var processContext = new CompoundProcessSnapshotContext(process, snapshotContext);
var processSelection = await _processMappingMapper.MapToModel(snapshotCompoundProcessSelection, processContext);
processSelectionGroup.AddProcessSelection(processSelection);
}
public override Task <IQualificationStep> MapToModel(SnapshotQualificationStep snapshot, SnapshotContext snapshotContext)
{
var qualificationStep = createQualificationStepFrom(snapshot.Type);
if (qualificationStep == null)
{
_logger.AddWarning(PKSimConstants.Error.CouldNotFindQualificationStep(snapshot.Type));
return(Task.FromResult <IQualificationStep>(null));
}
mapQualificationStepPropertiesToModel(qualificationStep, snapshot, snapshotContext.Project);
return(Task.FromResult(qualificationStep));
}
private async Task updateProcesses(SnapshotCompound snapshot, ModelCompound compound, SnapshotContext snapshotContext)
{
var processes = await _processMapper.MapToModels(snapshot.Processes, snapshotContext);
processes?.Each(compound.AddProcess);
}
public override async Task <IPopulationAnalysisField> MapToModel(PopulationAnalysisField snapshot, SnapshotContext snapshotContext)
{
var populationAnalysisField = await createFieldFrom(snapshot, snapshotContext);
MapSnapshotPropertiesToModel(snapshot, populationAnalysisField);
mapIf <PopulationAnalysisParameterField>(snapshot, populationAnalysisField, mapParameterFieldToModel);
mapIf <PopulationAnalysisPKParameterField>(snapshot, populationAnalysisField, mapPKParameterFieldToModel);
mapIf <PopulationAnalysisCovariateField>(snapshot, populationAnalysisField, mapCovariateFieldToModel);
mapIf <PopulationAnalysisOutputField>(snapshot, populationAnalysisField, mapOutputFieldToModel);
return(populationAnalysisField);
}
public override async Task <ModelFormulation> MapToModel(SnapshotFormulation snapshotFormulation, SnapshotContext snapshotContext)
{
var template = _formulationRepository.FormulationBy(snapshotFormulation.FormulationType);
var formulation = _cloner.Clone(template);
MapSnapshotPropertiesToModel(snapshotFormulation, formulation);
await UpdateParametersFromSnapshot(snapshotFormulation, formulation, snapshotContext);
formulation.UpdateParticleParametersVisibility();
return(formulation);
}
public override async Task <ModelPopulation> MapToModel(SnapshotPopulation snapshot, SnapshotContext snapshotContext)
{
var randomPopulationSettings = await _randomPopulationSettingsMapper.MapToModel(snapshot.Settings, snapshotContext);
//Do not add default molecule variability as this will be loaded from snapshot
var population = await _randomPopulationFactory.CreateFor(randomPopulationSettings, CancellationToken.None, snapshot.Seed, addMoleculeParametersVariability : false);
MapSnapshotPropertiesToModel(snapshot, population);
await _advancedParameterMapper.MapToModel(snapshot.AdvancedParameters, population, snapshotContext);
return(population);
}
public ParameterSnapshotContext(IParameter parameter, SnapshotContext baseContext) : base(baseContext)
{
Parameter = parameter;
}
private Task mapParameters <T>(IReadOnlyList <T> snapshots, Func <T, IParameter> parameterRetrieverFunc, Func <T, string> parameterIdentifierFunc, string containerDescriptor, SnapshotContext snapshotContext, bool showParameterNotFoundWarning = true) where T : SnapshotParameter
{
if (snapshots == null || !snapshots.Any())
{
return(Task.FromResult(false));
}
var tasks = new List <Task>();
foreach (var snapshot in snapshots)
{
var parameter = parameterRetrieverFunc(snapshot);
if (parameter == null)
{
if (showParameterNotFoundWarning)
{
_logger.AddWarning(PKSimConstants.Error.SnapshotParameterNotFoundInContainer(parameterIdentifierFunc(snapshot), containerDescriptor));
}
}
else
{
tasks.Add(MapToModel(snapshot, new ParameterSnapshotContext(parameter, snapshotContext)));
}
}
return(Task.WhenAll(tasks));
}
public virtual Task MapParameters(IReadOnlyList <SnapshotParameter> snapshots, IContainer container, string containerDescriptor, SnapshotContext snapshotContext)
{
return(mapParameters(snapshots, x => container.Parameter(x.Name), x => x.Name, containerDescriptor, snapshotContext));
}
public virtual Task MapLocalizedParameters(IReadOnlyList <LocalizedParameter> localizedParameters, IContainer container, SnapshotContext snapshotContext, bool showParameterNotFoundWarning = true)
{
//undefined or empty or actually not localized parameters (coming from conversions probably)
if (localizedParameters == null || !localizedParameters.Any() || localizedParameters.All(x => x.Path.IsNullOrEmpty()))
{
return(Task.FromResult(false));
}
var allParameters = _containerTask.CacheAllChildren <IParameter>(container);
return(mapParameters(localizedParameters, x => allParameters[x.Path], x => x.Path, container.Name, snapshotContext, showParameterNotFoundWarning));
}
public SimulationAnalysisContext(IEnumerable <ModelDataRepository> dataRepositories, SnapshotContext baseContext) : base(baseContext)
{
AddDataRepositories(dataRepositories);
}
private async Task updatePopulationComparisonModel(PopulationSimulationComparison populationSimulationComparison, SimulationComparison snapshot, SnapshotContext snapshotContext)
{
var simulationComparisonContext = new SimulationAnalysisContext(snapshotContext.Project.AllObservedData, snapshotContext);
var allPopulationAnalysis = await _populationAnalysisChartMapper.MapToModels(snapshot.PopulationComparisons, simulationComparisonContext);
allPopulationAnalysis?.Each(populationSimulationComparison.AddAnalysis);
populationSimulationComparison.ReferenceGroupingItem = snapshot.ReferenceGroupingItem;
populationSimulationComparison.ReferenceSimulation = snapshotContext.Project.BuildingBlockByName <PopulationSimulation>(snapshot.ReferenceSimulation);
}
public override async Task <ModelDataInfo> MapToModel(SnapshotDataInfo snapshot, SnapshotContext snapshotContext)
{
var origin = ModelValueFor(snapshot.Origin, ColumnOrigins.Undefined);
var dataInfo = new ModelDataInfo(origin)
{
AuxiliaryType = snapshot.AuxiliaryType,
Category = snapshot.Category,
ComparisonThreshold = snapshot.ComparisonThreshold,
LLOQ = snapshot.LLOQ,
MolWeight = molWeightToBaseValue(snapshot),
};
var extendedProperties = await _extendedPropertyMapper.MapToModels(snapshot.ExtendedProperties, snapshotContext);
extendedProperties?.Each(dataInfo.ExtendedProperties.Add);
return(dataInfo);
}
public override async Task <ModelParameterIdentification> MapToModel(SnapshotParameterIdentification snapshot, SnapshotContext snapshotContext)
{
var parameterIdentification = _objectBaseFactory.Create <ModelParameterIdentification>();
var parameterIdentificationContext = new ParameterIdentificationContext(parameterIdentification, snapshotContext);
MapSnapshotPropertiesToModel(snapshot, parameterIdentification);
snapshot.Simulations?.Each(s => { addSimulation(s, parameterIdentification, snapshotContext.Project); });
await _parameterIdentificationConfigurationMapper.MapToModel(snapshot.Configuration, parameterIdentificationContext);
var outputMappings = await _outputMappingMapper.MapToModels(snapshot.OutputMappings, parameterIdentificationContext);
outputMappings?.Each(parameterIdentification.AddOutputMapping);
var identificationParameters = await _identificationParameterMapper.MapToModels(snapshot.IdentificationParameters, parameterIdentificationContext);
identificationParameters?.Each(parameterIdentification.AddIdentificationParameter);
var simulationAnalysis = await _parameterIdentificationAnalysisMapper.MapToModels(snapshot.Analyses, parameterIdentificationContext);
simulationAnalysis?.Each(parameterIdentification.AddAnalysis);
parameterIdentification.IsLoaded = true;
return(parameterIdentification);
}
public override async Task <ModelEvent> MapToModel(SnapshotEvent snapshotEvent, SnapshotContext snapshotContext)
{
var modelEvent = _eventFactory.Create(snapshotEvent.Template);
MapSnapshotPropertiesToModel(snapshotEvent, modelEvent);
await UpdateParametersFromSnapshot(snapshotEvent, modelEvent, snapshotContext, snapshotEvent.Template);
return(modelEvent);
}
public override Task <ModelValueOrigin> MapToModel(SnapshotValueOrigin snapshot, SnapshotContext snapshotContext)
{
return(Task.FromException <ModelValueOrigin>(new SnapshotMapToModelNotSupportedException <ModelValueOrigin, ModelValueOrigin>()));
}
private async Task <IPopulationAnalysisField> createFieldFrom(PopulationAnalysisField snapshot, SnapshotContext snapshotContext)
{
if (snapshot.ParameterPath != null)
{
return(new PopulationAnalysisParameterField());
}
if (snapshot.PKParameter != null)
{
return(new PopulationAnalysisPKParameterField());
}
if (snapshot.Covariate != null)
{
return(new PopulationAnalysisCovariateField());
}
if (snapshot.GroupingDefinition != null)
{
var groupingDefinition = await _groupingDefinitionMapper.MapToModel(snapshot.GroupingDefinition, snapshotContext);
return(new PopulationAnalysisGroupingField(groupingDefinition));
}
return(new PopulationAnalysisOutputField());
}
public override Task <ModelParameterIdentificationRunMode> MapToModel(SnapshotParameterIdentificationRunMode snapshot, SnapshotContext snapshotContext)
{
return(Task.FromResult(mapRunModeFrom(snapshot)));
}
public override async Task <ModelCompound> MapToModel(SnapshotCompound snapshot, SnapshotContext snapshotContext)
{
var compound = _compoundFactory.Create();
MapSnapshotPropertiesToModel(snapshot, compound);
_calculationMethodCacheMapper.UpdateCalculationMethodCache(compound, snapshot.CalculationMethods);
await updateAlternatives(compound, snapshot.Lipophilicity, COMPOUND_LIPOPHILICITY, snapshotContext);
await updateAlternatives(compound, snapshot.FractionUnbound, COMPOUND_FRACTION_UNBOUND, snapshotContext);
await updateAlternatives(compound, snapshot.Solubility, COMPOUND_SOLUBILITY, snapshotContext);
await updateAlternatives(compound, snapshot.IntestinalPermeability, COMPOUND_INTESTINAL_PERMEABILITY, snapshotContext);
await updateAlternatives(compound, snapshot.Permeability, COMPOUND_PERMEABILITY, snapshotContext);
updatePkaTypes(compound, snapshot);
await updateProcesses(snapshot, compound, snapshotContext);
await UpdateParametersFromSnapshot(snapshot, compound, snapshotContext);
synchronizeMolWeightValueOrigins(compound);
return(compound);
}
public override async Task <ModelQualificationPlan> MapToModel(SnapshotQualificationPlan snapshot, SnapshotContext snapshotContext)
{
var qualificationPlan = _objectBaseFactory.Create <ModelQualificationPlan>();
MapSnapshotPropertiesToModel(snapshot, qualificationPlan);
var qualificationSteps = await _qualificationStepMapper.MapToModels(snapshot.Steps, snapshotContext);
qualificationSteps?.Each(qualificationPlan.Add);
return(qualificationPlan);
}
private async Task updateAlternatives(ModelCompound compound, Alternative[] snapshotAlternatives, string alternativeGroupName, SnapshotContext snapshotContext)
{
if (snapshotAlternatives == null)
{
return;
}
var alternativeGroup = compound.ParameterAlternativeGroup(alternativeGroupName);
//Remove all alternatives except calculated ones
alternativeGroup.AllAlternatives.ToList().Where(x => !x.IsCalculated).Each(alternativeGroup.RemoveAlternative);
//Reset the default flag that will be read from snapshot
alternativeGroup.AllAlternatives.Each(x => x.IsDefault = false);
var alternativeSnapshotContext = new AlternativeMapperSnapshotContext(alternativeGroup, snapshotContext);
var alternatives = await _alternativeMapper.MapToModels(snapshotAlternatives, alternativeSnapshotContext);
alternatives?.Each(alternativeGroup.AddAlternative);
//Ensure that we have at least one default alternative (might not be the case if only calculated alternatives were saved)
var defaultAlternative = alternativeGroup.DefaultAlternative;
if (defaultAlternative != null)
{
defaultAlternative.IsDefault = true;
}
}
private Task <IndividualSimulationComparison> createIndividualComparisonModel(SimulationComparison snapshot, SnapshotContext snapshotContext)
{
var simulationComparisonContext = new SimulationAnalysisContext(snapshotContext.Project.AllObservedData, snapshotContext);
var comparedSimulations = allComparedSimulationsFrom <IndividualSimulation>(snapshot, snapshotContext.Project);
comparedSimulations.Each(s => simulationComparisonContext.AddDataRepository(s.DataRepository));
return(_individualSimulationComparisonMapper.MapToModel(snapshot.IndividualComparison, simulationComparisonContext));
}
private async Task <CompoundProcessesSelection> modelProcessSelectionFrom(CompoundProcessSelection[] snapshotProcesses, Model.Compound compound, ISimulationSubject simulationSubject, SnapshotContext snapshotContext)
{
var compoundProcessesSelection = new CompoundProcessesSelection();
if (snapshotProcesses == null)
{
return(compoundProcessesSelection);
}
foreach (var snapshotProcess in snapshotProcesses)
{
var process = compound.ProcessByName(snapshotProcess.Name) ?? notSelectedProcessFrom(snapshotProcess, simulationSubject);
if (process == null)
{
//No process found and a name was specified. This is a snapshot that is corrupted
if (!string.IsNullOrEmpty(snapshotProcess.Name))
{
_logger.AddWarning(PKSimConstants.Error.ProcessNotFoundInCompound(snapshotProcess.Name, compound.Name));
}
continue;
}
await addProcessToProcessSelection(compoundProcessesSelection, snapshotProcess, process, snapshotContext);
}
return(compoundProcessesSelection);
}
public override async Task <ISimulationComparison> MapToModel(SimulationComparison snapshot, SnapshotContext snapshotContext)
{
var simulationComparison = await createSimulationComparisonFrom(snapshot, snapshotContext);
MapSnapshotPropertiesToModel(snapshot, simulationComparison);
simulationComparison.IsLoaded = true;
return(simulationComparison);
}
public CalculationMethodCacheSnapshotContext(ModelCalculationMethodCache calculationMethodCache, SnapshotContext baseContext) : base(baseContext)
{
CalculationMethodCache = calculationMethodCache;
}
private async Task <ISimulationComparison> createSimulationComparisonFrom(SimulationComparison snapshot, SnapshotContext snapshotContext)
{
var project = snapshotContext.Project;
if (snapshot.IndividualComparison != null)
{
var individualSimulationComparison = await createIndividualComparisonModel(snapshot, snapshotContext);
return(addSimulationsToComparison(individualSimulationComparison, snapshot, project));
}
var populationSimulationComparison = _objectBaseFactory.Create <PopulationSimulationComparison>();
await updatePopulationComparisonModel(populationSimulationComparison, snapshot, snapshotContext);
return(addSimulationsToComparison(populationSimulationComparison, snapshot, project));
}
