private void exportSimulationToFile(Simulation simulation, string moBiFile) { _lazyLoadTask.Load(simulation); if (simulation.IsImported) { throw new PKSimException(PKSimConstants.Error.CannotExportAnImportedSimulation); } var configuration = _buildConfigurationTask.CreateFor(simulation, shouldValidate: true, createAgingDataInSimulation: false); var moBiSimulation = _simulationMapper.MapFrom(simulation, configuration, shouldCloneModel: false); updateObserverForAllFlag(moBiSimulation); updateRepresentationInfo(moBiSimulation); updateFormulaIdIn(moBiSimulation); var simulationTransfer = new SimulationTransfer { Simulation = moBiSimulation, JournalPath = _journalRetriever.JournalFullPath }; var currentProject = _projectRetriever.CurrentProject; if (currentProject != null) { simulationTransfer.AllObservedData = simulation.UsedObservedData.Select(o => currentProject.ObservedDataBy(o.Id)).ToList(); simulationTransfer.Favorites = currentProject.Favorites; } _simulationPersistor.Save(simulationTransfer, moBiFile); }
private void exportToDirectory(ISimulation simulation, string exportDirectory) { var fileName = createFilePathFor(simulation, exportDirectory, Constants.Filter.XML_EXTENSION); var modelCoreSimulation = _simulationToModelCoreSimulationMapper.MapFrom(simulation, shouldCloneModel: false); _simModelExporter.ExportSimModelXml(modelCoreSimulation, fileName); }
private Task runSimulation(IndividualSimulation simulation, bool exportAll, bool raiseEvents, bool checkForNegativeValues) { //Should be done outside of the Task.Run to ensure that any event that might be raised by this action won't cause threading issue updatePersistableFor(simulation, exportAll); return(Task.Run(() => { var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(simulation, shouldCloneModel: false); var simRunOptions = new SimulationRunOptions { SimModelExportMode = SimModelExportMode.Optimized, CheckForNegativeValues = checkForNegativeValues }; var simResults = _simModelManager.RunSimulation(modelCoreSimulation, simRunOptions); if (!simResults.Success) { return; } _simulationResultsSynchronizer.Synchronize(simulation, simResults.Results); simulation.ClearPKCache(); if (raiseEvents) { _eventPublisher.PublishEvent(new SimulationResultsUpdatedEvent(simulation)); } })); }
private ISimModelBatch createSimModelBatch(ISimulation simulation) { var simModelBatch = _simModelBatchFactory.Create(); var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(simulation, shouldCloneModel: true); _timeGridUpdater.UpdateSimulationTimeGrid(modelCoreSimulation, _parameterIdentification.Configuration.RemoveLLOQMode, _parameterIdentification.AllDataRepositoryMappedFor(simulation)); _outputSelectionUpdater.UpdateOutputsIn(modelCoreSimulation, _parameterIdentification.AllOutputsMappedFor(simulation)); simModelBatch.InitializeWith(modelCoreSimulation, _parameterIdentification.PathOfOptimizedParameterBelongingTo(simulation), simulationResultsName: Captions.ParameterIdentification.SimulationResultsForRun(RunResult.Index)); return(simModelBatch); }
protected override void Context() { _eventPublisher = A.Fake <IEventPublisher>(); _sensitivityAnalysisVariationDataCreator = A.Fake <ISensitivityAnalysisVariationDataCreator>(); _populationRunner = A.Fake <IPopulationRunner>(); _modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>(); _runResultCalculator = A.Fake <ISensitivityAnalysisRunResultCalculator>(); _simulationPersistableUpdater = A.Fake <ISimulationPersistableUpdater>(); sut = new SensitivityAnalysisEngine(_eventPublisher, _sensitivityAnalysisVariationDataCreator, _populationRunner, _modelCoreSimulationMapper, _runResultCalculator, _simulationPersistableUpdater); _sensitivityAnalysis = A.Fake <SensitivityAnalysis>(); _modelCoreSimulation = A.Fake <IModelCoreSimulation>(); A.CallTo(() => _modelCoreSimulationMapper.MapFrom(_sensitivityAnalysis.Simulation, true)).Returns(_modelCoreSimulation); }
private Task runSimulation(IndividualSimulation simulation, SimulationRunOptions simulationRunOptions) { return(Task.Run(() => { var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(simulation, shouldCloneModel: false); var simResults = _simModelManager.RunSimulation(modelCoreSimulation, simulationRunOptions); if (!simResults.Success) { return; } _simulationResultsSynchronizer.Synchronize(simulation, simResults.Results); updateResultsName(simulation); simulation.ClearPKCache(); raiseEvent(new SimulationResultsUpdatedEvent(simulation)); })); }
public async Task <PopulationRunResults> RunAsync(PopulationSimulation populationSimulation, SimulationRunOptions simulationRunOptions) { _progressUpdater = _progressManager.Create(); _progressUpdater.Initialize(populationSimulation.NumberOfItems, PKSimConstants.UI.Calculating); var begin = SystemTime.UtcNow(); try { var populationData = _populationExporter.CreatePopulationDataFor(populationSimulation); var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(populationSimulation, shouldCloneModel: false); var runOptions = new RunOptions { NumberOfCoresToUse = _userSettings.MaximumNumberOfCoresToUse }; _eventPublisher.PublishEvent(new SimulationRunStartedEvent()); var populationRunResults = await _populationRunner.RunPopulationAsync(modelCoreSimulation, runOptions, populationData, populationSimulation.AgingData.ToDataTable()); _simulationResultsSynchronizer.Synchronize(populationSimulation, populationRunResults.Results); _populationSimulationAnalysisSynchronizer.UpdateAnalysesDefinedIn(populationSimulation); _eventPublisher.PublishEvent(new SimulationResultsUpdatedEvent(populationSimulation)); return(populationRunResults); } catch (OperationCanceledException) { simulationTerminated(); return(null); } catch (Exception) { simulationTerminated(); throw; } finally { var end = SystemTime.UtcNow(); var timeSpent = end - begin; _eventPublisher.PublishEvent(new SimulationRunFinishedEvent(populationSimulation, timeSpent)); } }
public async Task RunAsync(PopulationSimulation populationSimulation) { _progressUpdater = _progressManager.Create(); _progressUpdater.Initialize(populationSimulation.NumberOfItems, PKSimConstants.UI.Calculating); _populationRunner.NumberOfCoresToUse = _userSettings.MaximumNumberOfCoresToUse; //make sure that thread methods always catch and handle any exception, //otherwise we risk unplanned application termination var begin = SystemTime.UtcNow(); try { var populationData = _populationExporter.CreatePopulationDataFor(populationSimulation); var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(populationSimulation, shouldCloneModel: false); _simulationPersistableUpdater.UpdatePersistableFromSettings(populationSimulation); _eventPublisher.PublishEvent(new SimulationRunStartedEvent()); var populationRunResults = await _populationRunner.RunPopulationAsync(modelCoreSimulation, populationData, populationSimulation.AgingData.ToDataTable()); _simulationResultsSynchronizer.Synchronize(populationSimulation, populationRunResults.Results); _populationSimulationAnalysisSynchronizer.UpdateAnalysesDefinedIn(populationSimulation); _eventPublisher.PublishEvent(new SimulationResultsUpdatedEvent(populationSimulation)); } catch (OperationCanceledException) { simulationTerminated(); } catch (Exception ex) { _exceptionManager.LogException(ex); simulationTerminated(); } finally { var end = SystemTime.UtcNow(); var timeSpent = end - begin; _eventPublisher.PublishEvent(new SimulationRunFinishedEvent(populationSimulation, timeSpent)); } }
public async Task StartAsync(SensitivityAnalysis sensitivityAnalysis, SensitivityAnalysisRunOptions runOptions) { _sensitivityAnalysis = sensitivityAnalysis; _eventPublisher.PublishEvent(new SensitivityAnalysisStartedEvent(sensitivityAnalysis)); try { var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(sensitivityAnalysis.Simulation, shouldCloneModel: true); _simulationPersistableUpdater.UpdateSimulationPersistable(modelCoreSimulation); var variationData = _sensitivityAnalysisVariationDataCreator.CreateForRun(sensitivityAnalysis); var runResults = await _populationRunner.RunPopulationAsync(modelCoreSimulation, runOptions, variationData.ToDataTable()); sensitivityAnalysis.Results = await calculateSensitivityBasedOn(sensitivityAnalysis, variationData, runResults, runOptions); _eventPublisher.PublishEvent(new SensitivityAnalysisResultsUpdatedEvent(sensitivityAnalysis)); } finally { _eventPublisher.PublishEvent(new SensitivityAnalysisTerminatedEvent(sensitivityAnalysis)); _sensitivityAnalysis = null; } }
protected override void Context() { _modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>(); _residualCalculatorFactory = A.Fake <IResidualCalculatorFactory>(); _timeGridUpdater = A.Fake <ITimeGridUpdater>(); _simModelBatchFactory = A.Fake <ISimModelBatchFactory>(); _optimizationAlgorithmMapper = A.Fake <IParameterIdentificationAlgorithmToOptmizationAlgorithmMapper>(); _outputSelectionUpdater = A.Fake <IOutputSelectionUpdater>(); _coreUserSettings = A.Fake <ICoreUserSettings>(); _jacobianMatrixCalculator = A.Fake <IJacobianMatrixCalculator>(); _coreUserSettings.MaximumNumberOfCoresToUse = 2; sut = new ParameterIdentificationRun(_residualCalculatorFactory, _timeGridUpdater, _simModelBatchFactory, _modelCoreSimulationMapper, _optimizationAlgorithmMapper, _outputSelectionUpdater, _coreUserSettings, _jacobianMatrixCalculator); _simulation = A.Fake <ISimulation>(); _parameter1 = A.Fake <IParameter>(); _parameter1.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _parameter1.Value = 15; _parameter2 = A.Fake <IParameter>(); _parameter2.Value = 35; _parameter2.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _parameterIdentification = new ParameterIdentification(); _parameterIdentification.Configuration.LLOQMode = LLOQModes.OnlyObservedData; _parameterIdentification.Configuration.RemoveLLOQMode = RemoveLLOQModes.NoTrailing; _parameterIdentification.AddSimulation(_simulation); _parameterSelection1 = ParameterSelectionFor(_parameter1, "ParameterPath1"); _parameterSelection2 = ParameterSelectionFor(_parameter2, "ParameterPath2"); _identificationParameter = DomainHelperForSpecs.IdentificationParameter("IdParam", min: 10, max: 20, startValue: 15); _identificationParameter.AddLinkedParameter(_parameterSelection1); _identificationParameter.AddLinkedParameter(_parameterSelection2); _modelCoreSimulation = A.Fake <IModelCoreSimulation>(); A.CallTo(() => _modelCoreSimulationMapper.MapFrom(_simulation, true)).Returns(_modelCoreSimulation); _outputMapping = A.Fake <OutputMapping>(); A.CallTo(() => _outputMapping.UsesSimulation(_simulation)).Returns(true); A.CallTo(() => _outputMapping.WeightedObservedData.ObservedData).Returns(DomainHelperForSpecs.ObservedData()); _parameterIdentification.AddOutputMapping(_outputMapping); _simModelBatch = A.Fake <ISimModelBatch>(); A.CallTo(() => _simModelBatchFactory.Create()).Returns(_simModelBatch); _parameterIdentification.AddIdentificationParameter(_identificationParameter); _residualCalculator = A.Fake <IResidualCalculator>(); A.CallTo(_residualCalculatorFactory).WithReturnType <IResidualCalculator>().Returns(_residualCalculator); _algorithm = A.Fake <IOptimizationAlgorithm>(); A.CallTo(() => _optimizationAlgorithmMapper.MapFrom(_parameterIdentification.AlgorithmProperties)).Returns(_algorithm); _cancellationTokenSource = new CancellationTokenSource(); _cancellationToken = _cancellationTokenSource.Token; _runInitializer = A.Fake <IParameterIdentifcationRunInitializer>(); A.CallTo(() => _runInitializer.InitializeRun()).ReturnsAsync(_parameterIdentification); PerformExtraInitializationSteps(); sut.InitializeWith(_runInitializer); }
public void ExportForCluster(PopulationSimulation populationSimulation) { _lazyLoadTask.Load(populationSimulation); if (settingsRequired(populationSimulation)) { var outputSelections = _simulationSettingsRetriever.SettingsFor(populationSimulation); if (outputSelections == null) { return; } populationSimulation.OutputSelections.UpdatePropertiesFrom(outputSelections, _cloner); } FileSelection populationExport; using (var presenter = _applicationController.Start <ISelectFilePresenter>()) { populationExport = presenter.SelectDirectory(PKSimConstants.UI.ExportForClusterSimulationTitle, Constants.DirectoryKey.SIM_MODEL_XML); } if (populationExport == null) { return; } var populationFolder = populationExport.FilePath; var existingFiles = Directory.GetFiles(populationFolder); if (existingFiles.Any()) { if (_dialogCreator.MessageBoxYesNo(PKSimConstants.UI.DeleteFilesIn(populationFolder)).Equals(ViewResult.No)) { return; } existingFiles.Each(FileHelper.DeleteFile); } var fileName = populationSimulation.Name; var modelFileFullPath = Path.Combine(populationFolder, $"{fileName}.xml"); var agingFileFullPath = Path.Combine(populationFolder, $"{fileName}{CoreConstants.Population.TableParameterExport}.csv"); var outputDeffinitionFileFullPath = Path.Combine(populationFolder, $"{fileName}{CoreConstants.Population.OutputDefinitionExport}.csv"); //Model _simModelExporter.Export(_modelCoreSimulationMapper.MapFrom(populationSimulation, shouldCloneModel: false), modelFileFullPath); // Outputs var outputSelection = populationSimulation.OutputSelections; exportOutputDefiniton(outputSelection, outputDeffinitionFileFullPath); //all values var dataTable = CreatePopulationDataFor(populationSimulation); dataTable.ExportToCSV(Path.Combine(populationFolder, $"{fileName}.csv"), comments: getProjectMetaInfo(populationExport.Description)); //all aging data var agingData = populationSimulation.AgingData.ToDataTable(); if (agingData.Rows.Count > 0) { agingData.ExportToCSV(agingFileFullPath, comments: getProjectMetaInfo(populationExport.Description)); } }
public Task ExportSimulationToSimModelXmlAsync(Simulation simulation, string fileName) { return(Task.Run(() => _simModelExporter.Export(_coreSimulationMapper.MapFrom(simulation, shouldCloneModel: false), fileName))); }
public Task ExportSimulationToCppAsync(Simulation simulation, string outputFolder) { _lazyLoadTask.Load(simulation); return(Task.Run(() => _simModelExporter.ExportCppCode(_coreSimulationMapper.MapFrom(simulation, shouldCloneModel: false), outputFolder, FormulaExportMode.Formula))); }