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>()); }