protected override ISimulationAnalysisPresenter PresenterFor(ISimulationAnalysis simulationAnalysis, IContainer container)
{
if (simulationAnalysis.IsAnImplementationOf <SimulationTimeProfileChart>())
{
return(container.Resolve <ISimulationTimeProfileChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <BoxWhiskerAnalysisChart>())
{
return(container.Resolve <IEditBoxWhiskerAnalysisChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ScatterAnalysisChart>())
{
return(container.Resolve <IEditScatterAnalysisChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <RangeAnalysisChart>())
{
return(container.Resolve <IEditRangeAnalysisChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <TimeProfileAnalysisChart>())
{
return(container.Resolve <IEditTimeProfileAnalysisChartPresenter>());
}
return(null);
}
public void CreateBuildingBlock()
{
var buildingBlockTask = _container.Resolve <IBuildingBlockTask <TBuildingBlock> >();
buildingBlockTask.AddToProject();
Edit(_buildingBlockRepository.All <TBuildingBlock>().LastOrDefault());
}
protected override void Context()
{
_ioc = A.Fake <IoC>();
_showContainerPresenter = A.Fake <IEditContainerInSimulationPresenter>();
_editQuantityPresenter = A.Fake <IEditQuantityInSimulationPresenter>();
_showReactionPresenter = A.Fake <IEditReactionInSimulationPresenter>();
A.CallTo(() => _ioc.Resolve <IEditQuantityInSimulationPresenter>()).Returns(_editQuantityPresenter);
A.CallTo(() => _ioc.Resolve <IEditReactionInSimulationPresenter>()).Returns(_showReactionPresenter);
A.CallTo(() => _ioc.Resolve <IEditContainerInSimulationPresenter>()).Returns(_showContainerPresenter);
sut = new EditInSimulationPresenterFactory(_ioc);
}
private IResidualCalculator createCalculator(LLOQMode lloqMode)
{
// in case of log scale can arise problems, therefore different LLOQMode methods are available
if (lloqMode == LLOQModes.OnlyObservedData)
{
return(_container.Resolve <ResidualCalculatorForOnlyObservedData>());
}
if (lloqMode == LLOQModes.SimulationOutputAsObservedDataLLOQ)
{
return(_container.Resolve <ResidualCalculatorForSimulationOutputAsObservedDataLLOQ>());
}
throw new ArgumentOutOfRangeException(nameof(lloqMode));
}
protected override void Context()
{
sut = new ObjectPathXmlAttributeMapper();
_container = A.Fake <IContainer>();
A.CallTo(() => _container.Resolve <IObjectPathFactory>()).Returns(new ObjectPathFactoryForSpecs());
_serializationContext = SerializationTransaction.Create(_container);
}
public void Convert(XElement element)
{
foreach (var parameterCacheElement in element.Descendants("ParameterValuesCache").ToList())
{
var parameterValuesCache = new ParameterValuesCache();
foreach (var dataColumnNode in parameterCacheElement.Descendants(ConverterConstants.Serialization.DATA_TABLE_COLUMN))
{
var parameterValues = new ParameterValues(dataColumnNode.GetAttribute(CoreConstants.Serialization.Attribute.Name));
parameterValuesCache.Add(parameterValues);
}
var documentElement = parameterCacheElement.Descendants("DocumentElement").First();
foreach (var parameterValuesElement in documentElement.Descendants("ParameterValues"))
{
int index = 0;
foreach (var parameterValue in parameterValuesElement.Descendants())
{
var parameterValues = parameterValuesCache.ParameterValuesAt(index);
parameterValues.Add(parameterValue.Value.ConvertedTo <double>());
index++;
}
}
var writer = _container.Resolve <IXmlWriter <ParameterValuesCache> >();
var newElement = writer.WriteFor(parameterValuesCache, SerializationTransaction.Create());
var parent = parameterCacheElement.Parent;
parameterCacheElement.Remove();
parent.Add(newElement);
}
}
private void convertProject(IProject project)
{
if (!_projectObservedDataElementCache.Any())
{
return;
}
var serializerRepository = _container.Resolve <IPKSimXmlSerializerRepository>();
var serializer = serializerRepository.SerializerFor <DataRepository>();
using (var serializationContext = SerializationTransaction.Create(dimensionFactory: _dimensionFactory, withIdRepository: new WithIdRepository()))
{
var context = serializationContext;
_projectObservedDataElementCache.Each(e =>
{
_observedDataConvertor.ConvertDimensionIn(e);
project.AddObservedData(serializer.Deserialize <DataRepository>(e, context));
});
}
_projectObservedDataElementCache.Clear();
project.AllObservedData.Each(x => _observedDataConvertor.Convert(project, x, _originalVersion));
_converted = true;
}
public SerializationContext Create(SerializationContext parentSerializationContext = null)
{
var projectRetriever = _container.Resolve <IMoBiProjectRetriever>();
var project = projectRetriever.Current;
var idRepository = new WithIdRepository();
var allRepositories = new List <DataRepository>();
if (parentSerializationContext != null)
{
allRepositories.AddRange(parentSerializationContext.Repositories);
parentSerializationContext.IdRepository.All().Each(idRepository.Register);
}
//if project is defined, retrieved all available results from existing simulation. Required to ensure correct deserialization
if (project != null)
{
var allSimulations = project.Simulations;
var allSimulationResults = allSimulations.Where(s => s.HasResults).Select(s => s.Results);
allRepositories.AddRange(allSimulationResults.Union(project.AllObservedData));
//Also register simulations to ensure that they are available as well for deserialization
allSimulations.Each(idRepository.Register);
}
allRepositories.Each(idRepository.Register);
return(new SerializationContext(_dimensionFactory, _objectBaseFactory, idRepository, allRepositories, _cloneManagerForModel, _container));
}
public SerializationContext Create(IEnumerable <DataRepository> dataRepositories = null, IEnumerable <IWithId> externalReferences = null)
{
var projectRetriever = _container.Resolve <IPKSimProjectRetriever>();
var project = projectRetriever.Current;
//do not use the pksim repository since we need to register the deserialized object afterwards
//this repository is only used to resolve the references
var withIdRepository = new WithIdRepository();
externalReferences?.Each(withIdRepository.Register);
var allRepositories = new List <DataRepository>();
if (project != null)
{
allRepositories.AddRange(project.All <IndividualSimulation>()
.Where(s => s.HasResults)
.Select(s => s.DataRepository)
.Union(project.AllObservedData));
}
if (dataRepositories != null)
{
allRepositories.AddRange(dataRepositories);
}
allRepositories.Each(withIdRepository.Register);
return(SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, withIdRepository, _cloneManagerForModel, allRepositories));
}
protected override void Context()
{
_container = A.Fake <IContainer>();
_timeProfileChartPresenter = A.Fake <ISimulationTimeProfileChartPresenter>();
A.CallTo(() => _container.Resolve <ISimulationTimeProfileChartPresenter>()).Returns(_timeProfileChartPresenter);
sut = new SimulationAnalysisPresenterFactory(_container);
}
protected override void Context()
{
_container = A.Fake <IContainer>();
sut = new ParameterIdentificationAlgorithmToOptmizationAlgorithmMapper(_container);
_optimizationAlgorithmProperties = new OptimizationAlgorithmProperties("Algo")
{
new ExtendedProperty <string> {
Name = "Toto", Value = "Test"
},
new ExtendedProperty <double> {
Name = "Tata", Value = 10d
},
new ExtendedProperty <bool> {
Name = "Does not exist", Value = false
}
};
_optimizationAlgorithm = A.Fake <IOptimizationAlgorithm>();
A.CallTo(() => _optimizationAlgorithm.Properties).Returns(new OptimizationAlgorithmProperties("Algo"));
_optimizationAlgorithm.Properties.Add(new ExtendedProperty <string> {
Name = "Toto", Value = "OLD"
});
_optimizationAlgorithm.Properties.Add(new ExtendedProperty <double> {
Name = "Tata", Value = 5d
});
_optimizationAlgorithm.Properties.Add(new ExtendedProperty <bool> {
Name = "TUTU", Value = true
});
A.CallTo(() => _container.Resolve <IOptimizationAlgorithm>(_optimizationAlgorithmProperties.Name)).Returns(_optimizationAlgorithm);
}
private IModalPresenter createModalPresenter(ICommandCollectorPresenter editSubPresenter, ICommandCollector commandCollector)
{
var modalPresenter = _container.Resolve <IModalPresenter>();
editSubPresenter.InitializeWith(commandCollector);
modalPresenter.Encapsulate(editSubPresenter);
return(modalPresenter);
}
public virtual T Create <T>(string id) where T : IObjectBase
{
var newObject = _container.Resolve <T>().WithId(id);
updateDimension(newObject);
updateCreationMetaData(newObject);
return(newObject);
}
private XElement createCovariateValuesCacheElement(IEnumerable <XElement> allCovariatesElement)
{
var covariateValuesCache = new CovariateValuesCache();
var individualCovariatesReader = _container.Resolve <IXmlReader <IndividualCovariates> >();
var covariateValuesCacheWriter = _container.Resolve <IXmlWriter <CovariateValuesCache> >();
var context = SerializationTransaction.Create(_container);
// List of old covariates as defined in PKSim 8.x and below
var allIndividualCovariates = new List <IndividualCovariates>();
foreach (var individualCovariatesElement in allCovariatesElement.Descendants("IndividualCovariates"))
{
var individualCovariates = individualCovariatesReader.ReadFrom(individualCovariatesElement, context);
allIndividualCovariates.Add(individualCovariates);
}
var allCovariateNames = allIndividualCovariates.FirstOrDefault()?.Attributes.Keys.ToList() ?? new List <string>();
allCovariateNames.Add(Constants.Population.GENDER);
allCovariateNames.Add(Constants.Population.POPULATION);
// Transform the old covariates in the new structure
foreach (var covariateName in allCovariateNames)
{
var covariateValues = new CovariateValues(covariateName);
if (string.Equals(covariateName, Constants.Population.GENDER))
{
covariateValues.Values = allIndividualCovariates.Select(x => x.Gender.Name).ToList();
}
else if (string.Equals(covariateName, Constants.Population.POPULATION))
{
covariateValues.Values = allIndividualCovariates.Select(x => x.Race.Name).ToList();
}
else
{
covariateValues.Values = allIndividualCovariates.Select(x => x.Covariate(covariateName)).ToList();
}
covariateValuesCache.Add(covariateValues);
}
return(covariateValuesCacheWriter.WriteFor(covariateValuesCache, context));
}
public IOptimizationAlgorithm MapFrom(OptimizationAlgorithmProperties optimizationAlgorithmProperties)
{
var algorithm = _container.Resolve <IOptimizationAlgorithm>(optimizationAlgorithmProperties.Name);
foreach (var property in optimizationAlgorithmProperties.Where(p => algorithm.Properties.Contains(p.Name)))
{
algorithm.Properties[property.Name].ValueAsObject = property.ValueAsObject;
}
return(algorithm);
}
public IEditInSimulationPresenter PresenterFor(IEntity entity)
{
if (entity.IsAnImplementationOf <IQuantity>())
{
return(_container.Resolve <IEditQuantityInSimulationPresenter>());
}
if (entity.IsAnImplementationOf <IReaction>())
{
return(_container.Resolve <IEditReactionInSimulationPresenter>());
}
if (entity.IsAnImplementationOf <IContainer>())
{
return(_container.Resolve <IEditContainerInSimulationPresenter>());
}
return(null);
}
public TChartType Create <TChartType>() where TChartType : CurveChart
{
var chart = _container.Resolve <TChartType>();
chart.Id = _idGenerator.NewId();
chart.ChartSettings.BackColor = _presentationUserSettings.ChartBackColor;
chart.ChartSettings.DiagramBackColor = _presentationUserSettings.ChartDiagramBackColor;
chart.DefaultYAxisScaling = _presentationUserSettings.DefaultChartYScaling;
return(chart);
}
protected override void Context()
{
_individual = new Individual();
_container = A.Fake <IContainer>();
_serializationContextFactory = A.Fake <ISerializationContextFactory>();
_simulationUpdater = A.Fake <ISimulationUpdaterAfterDeserialization>();
_eventPublisher = A.Fake <IEventPublisher>();
_xmlReaderIndividual = A.Fake <IXmlReader <Individual> >();
_xmlWriterIndividual = A.Fake <IXmlWriter <Individual> >();
_xmlReaderSimulation = A.Fake <IXmlReader <Simulation> >();
_xmlWriterSimulation = A.Fake <IXmlWriter <Simulation> >();
_objectConverterFinder = A.Fake <IObjectConverterFinder>();
_serializationContext = A.Fake <SerializationContext>();
A.CallTo(() => _container.Resolve <IXmlReader <Individual> >()).Returns(_xmlReaderIndividual);
A.CallTo(() => _container.Resolve <IXmlWriter <Individual> >()).Returns(_xmlWriterIndividual);
A.CallTo(() => _container.Resolve <IXmlReader <Simulation> >()).Returns(_xmlReaderSimulation);
A.CallTo(() => _container.Resolve <IXmlWriter <Simulation> >()).Returns(_xmlWriterSimulation);
_referenceResolver = A.Fake <IReferencesResolver>();
sut = new XmlSerializationManager(_referenceResolver, _container, _objectConverterFinder, _simulationUpdater, _eventPublisher, _serializationContextFactory);
A.CallTo(() => _serializationContextFactory.Create(null, null)).Returns(_serializationContext);
}
protected override void Context()
{
_idGenerator = A.Fake <IIdGenerator>();
_parameter = new PKSimParameter();
_ioC = A.Fake <OSPSuite.Utility.Container.IContainer>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_creationMetaDataFactory = A.Fake <ICreationMetaDataFactory>();
var dimensionFactory = A.Fake <IDimensionFactory>();
A.CallTo(() => dimensionFactory.NoDimension).Returns(Constants.Dimension.NO_DIMENSION);
A.CallTo(() => _dimensionRepository.DimensionFactory).Returns(dimensionFactory);
A.CallTo(() => _ioC.Resolve <IParameter>()).Returns(_parameter);
sut = new PKSimObjectBaseFactory(_ioC, _dimensionRepository, _idGenerator, _creationMetaDataFactory);
}
protected override void Context()
{
_dimensionFactory = A.Fake <ISerializationDimensionFactory>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_cloneManagerForModel = A.Fake <ICloneManagerForModel>();
_container = A.Fake <IContainer>();
sut = new SerializationContextFactory(_dimensionFactory, _objectBaseFactory, _container, _cloneManagerForModel);
_projectRetriever = A.Fake <IPKSimProjectRetriever>();
A.CallTo(() => _container.Resolve <IPKSimProjectRetriever>()).Returns(_projectRetriever);
_project = new PKSimProject();
A.CallTo(() => _projectRetriever.Current).Returns(_project);
}
public void LoadViews()
{
var views = new List <IResizableView>();
var model = new TestEnvironment().Model;
for (int i = 0; i < 2; i++)
{
var quantitySelectionDTOs = model.Root.GetAllChildren <IQuantity>(x => x.Persistable)
.MapAllUsing(_quantitySelectionDTOMapper);
var view = _container.Resolve <ITestResizableView>();
view.BindTo(quantitySelectionDTOs);
views.Add(view);
}
_configurableLayoutPresenter.AddViews(views);
views.Each(x => x.AdjustHeight());
views.Each(x => x.Repaint());
}
protected override void Context()
{
_individualList = new List <Individual>();
_individualBuildingBlockTask = A.Fake <IBuildingBlockTask <Individual> >();
_container = A.Fake <IContainer>();
A.CallTo(() => _container.Resolve <IBuildingBlockTask <Individual> >()).Returns(_individualBuildingBlockTask);
_view = A.Fake <IBuildingBlockSelectionView>();
_objectTypeResolver = A.Fake <IObjectTypeResolver>();
_individualRepository = A.Fake <IBuildingBlockRepository>();
A.CallTo(() => _individualRepository.All <Individual>()).Returns(_individualList);
_buildingBlockType = "Tralal";
A.CallTo(() => _objectTypeResolver.TypeFor <Individual>()).Returns(_buildingBlockType);
_toolTipCreator = A.Fake <IToolTipPartCreator>();
_buildingBlockSelection = A.Fake <IBuildingBlockSelectionDisplayer>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_emptySelection = new Individual().WithId("TOTO");
A.CallTo(() => _objectBaseFactory.Create <Individual>()).Returns(_emptySelection);
sut = new BuildingBlockSelectionPresenter <Individual>(_view, _objectTypeResolver, _individualRepository, _container, _objectBaseFactory, _buildingBlockSelection);
}
public void Visit(IndividualSimulation individualSimulation)
{
convertSimulation(individualSimulation);
if (!_simulationChartElementCache.Any())
{
return;
}
//load results is required so that charts can be loaded on the fly
_simulationResultsLoader.LoadResultsFor(individualSimulation);
var serializerRepository = _container.Resolve <IPKSimXmlSerializerRepository>();
var serializer = serializerRepository.SerializerFor <SimulationTimeProfileChart>();
using (var serializationContext = SerializationTransaction.Create(dimensionFactory: _dimensionFactory))
{
var context = serializationContext;
serializationContext.AddRepository(individualSimulation.DataRepository);
_simulationChartElementCache.Each(e => individualSimulation.AddAnalysis(serializer.Deserialize <SimulationTimeProfileChart>(e, context)));
}
_simulationChartElementCache.Clear();
}
protected virtual IXmlReader <TObject> XmlReaderFor <TObject>()
{
return(_container.Resolve <IXmlReader <TObject> >());
}
public ISimulationAnalysisPresenter PresenterFor(ISimulationAnalysis simulationAnalysis)
{
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationTimeProfileChart>())
{
return(_container.Resolve <IParameterIdentificationTimeProfileChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationResidualVsTimeChart>())
{
return(_container.Resolve <IParameterIdentificationResidualVsTimeChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationResidualHistogram>())
{
return(_container.Resolve <IParameterIdentificationResidualHistogramPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationPredictedVsObservedChart>())
{
return(_container.Resolve <IParameterIdentificationPredictedVsObservedChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationCorrelationMatrix>())
{
return(_container.Resolve <IParameterIdentificationCorrelationAnalysisPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationCovarianceMatrix>())
{
return(_container.Resolve <IParameterIdentificationCovarianceAnalysisPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationTimeProfileConfidenceIntervalChart>())
{
return(_container.Resolve <IParameterIdentificationTimeProfileConfidenceIntervalChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationTimeProfilePredictionIntervalChart>())
{
return(_container.Resolve <IParameterIdentificationTimeProfilePredictionIntervalChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationTimeProfileVPCIntervalChart>())
{
return(_container.Resolve <IParameterIdentificationTimeProfileVPCIntervalChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <ParameterIdentificationTimeProfileConfidenceIntervalChart>())
{
return(_container.Resolve <IParameterIdentificationTimeProfileConfidenceIntervalChartPresenter>());
}
if (simulationAnalysis.IsAnImplementationOf <SensitivityAnalysisPKParameterAnalysis>())
{
return(_container.Resolve <ISensitivityAnalysisPKParameterAnalysisPresenter>());
}
var specificPresenter = PresenterFor(simulationAnalysis, _container);
if (specificPresenter != null)
{
return(specificPresenter);
}
throw new ArgumentException(Error.CannotCreateChartPresenterForChart(simulationAnalysis.GetType()));
}
public ICustomParametersPresenter MapFrom(IContainer container)
{
return(_ioc.Resolve <IMultiParameterEditPresenter>());
}
public T Resolve <T>()
{
return(_container.Resolve <T>());
}
private void retrieveTask <TBuildingBlock>(TBuildingBlock buildingBlock) where TBuildingBlock : class, IBuildingBlock
{
_task = _container.Resolve <IInteractionTasksForBuildingBlock <TBuildingBlock> >();
}
public ICustomParametersPresenter MapFrom(IGroup group)
{
if (group.Name.Equals(CoreConstants.Groups.SIMULATION_SETTINGS))
{
return(_container.Resolve <IEditOutputSchemaPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.SOLVER_SETTINGS))
{
return(_container.Resolve <IEditSolverSettingsPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.FAVORITES))
{
return(_container.Resolve <IFavoriteParametersPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.BLOOD_FLOW_RATES))
{
return(_container.Resolve <IBloodFlowRatesParametersPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.FORMULATIONS))
{
return(_container.Resolve <IFormulationParametersPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.EVENTS))
{
return(_container.Resolve <IEventParametersPresenter>());
}
if (group.Name.Equals(CoreConstants.Groups.ALL))
{
return(_container.Resolve <IAllParametersPresenter>());
}
if (group.NameIsOneOf(CoreConstants.Groups.AllSimulationCompoundGroups))
{
return(_container.Resolve <ISimulationCompoundParametersPresenter>());
}
//dynamic parameters
if (group.Name.StartsWith(CoreConstants.Groups.COMPOUND_PROCESS_ITEM))
{
var presenter = _container.Resolve <IParametersByGroupPresenter>();
presenter.ShowFavorites = true;
presenter.HeaderVisible = true;
return(presenter);
}
if (group.Name.StartsWith(CoreConstants.Groups.RELATIVE_EXPRESSION_ITEM))
{
return(_container.Resolve <ISimulationExpressionsPresenter>());
}
if (group.Name.StartsWith(CoreConstants.Groups.COMPOUND_ITEM))
{
return(_container.Resolve <ICompoundInSimulationPresenter>());
}
if (group.Name.StartsWith(CoreConstants.Groups.PROTOCOL_ITEM))
{
return(_container.Resolve <IApplicationParametersPresenter>());
}
//no need to display parameters in relative expressions group. They will be displayed per molecule
if (group.Name.Equals(CoreConstants.Groups.RELATIVE_EXPRESSION))
{
return(null);
}
//no need to display parameters in Compound group. They will be displayed per molecule
if (group.Name.Equals(CoreConstants.Groups.COMPOUND))
{
return(null);
}
//no need to display parameters in Protocol group. They will be displayed per molecule
if (group.Name.Equals(CoreConstants.Groups.PROTOCOL))
{
return(null);
}
return(_container.Resolve <IMultiParameterEditPresenter>());
}