public async Task RunAsync(IndividualSimulation individualSimulation, SimulationRunOptions simulationRunOptions) { _shouldRaiseEvents = simulationRunOptions.RaiseEvents; initializeProgress(); _simModelManager.SimulationProgress += simulationProgress; //make sure that thread methods always catch and handle any exception, //otherwise we risk unplanned application termination var begin = SystemTime.UtcNow(); try { raiseEvent(new SimulationRunStartedEvent()); await runSimulation(individualSimulation, simulationRunOptions); } catch (Exception) { terminated(); throw; } finally { var end = SystemTime.UtcNow(); var timeSpent = end - begin; raiseEvent(new SimulationRunFinishedEvent(individualSimulation, timeSpent)); } }
private async Task exportSimulation(Simulation simulation, ExportRunOptions exportRunOptions) { var outputFolder = Path.Combine(exportRunOptions.OutputFolder, simulation.Name); DirectoryHelper.CreateDirectory(outputFolder); var simulationRunOptions = new SimulationRunOptions(); _lazyLoadTask.Load(simulation); _lazyLoadTask.LoadResults(simulation); if (!simulation.OutputSelections.HasSelection) { _logger.AddWarning($"Simulation '{simulation.Name}' does not have any selected output and will not be exported"); return; } if (exportRunOptions.RunSimulation) { await _simulationExporter.RunAndExport(simulation, outputFolder, simulationRunOptions, exportRunOptions.ExportMode); } else if (simulation.HasResults) { await _simulationExporter.Export(simulation, outputFolder, exportRunOptions.ExportMode); } else { _logger.AddWarning($"Simulation '{simulation.Name}' does not have any results and will not be exported"); } }
public override void GlobalContext() { base.GlobalContext(); _compoundProcessRepository = IoC.Resolve <ICompoundProcessRepository>(); _cloneManager = IoC.Resolve <ICloneManager>(); _enzymeFactory = IoC.Resolve <IIndividualEnzymeFactory>(); _transporterFactory = IoC.Resolve <IIndividualTransporterFactory>(); _modelPropertiesTask = IoC.Resolve <IModelPropertiesTask>(); _modelConfigurationRepository = IoC.Resolve <IModelConfigurationRepository>(); _compound = DomainFactoryForSpecs.CreateStandardCompound(); _individual = DomainFactoryForSpecs.CreateStandardIndividual(); _protocol = DomainFactoryForSpecs.CreateStandardIVBolusProtocol(); _enzyme = _enzymeFactory.CreateFor(_individual).DowncastTo <IndividualEnzyme>().WithName("CYP"); _enzyme.GetRelativeExpressionNormParameterFor(CoreConstants.Compartment.Plasma).Value = _relExpNormPls; _enzyme.GetRelativeExpressionNormParameterFor(CoreConstants.Compartment.BloodCells).Value = _relExpNormBloodCells; _enzyme.GetRelativeExpressionNormParameterFor(CoreConstants.Compartment.VascularEndothelium).Value = _relExpVascEndo; _individual.AddMolecule(_enzyme); _hct = _individual.Organism.Parameter(CoreConstants.Parameters.HCT).Value; _metabolizationProcess = _cloneManager.Clone(_compoundProcessRepository.ProcessByName(CoreConstantsForSpecs.Process.METABOLIZATION_SPECIFIC_FIRST_ORDER).DowncastTo <PartialProcess>()); _metabolizationProcess.Name = "My Partial Process"; _metabolizationProcess.Parameter(ConverterConstants.Parameter.CLspec).Value = 15; _compound.AddProcess(_metabolizationProcess); _simulationRunOptions = new SimulationRunOptions { RaiseEvents = false }; }
public async Task RunAndExport(Simulation simulation, string outputFolder, SimulationRunOptions simulationRunOptions, SimulationExportMode simulationExportMode, string projectName = null) { _logger.AddDebug($"Running simulation '{simulation.Name}'"); await _simulationRunner.RunSimulation(simulation, simulationRunOptions); await Export(simulation, outputFolder, simulationExportMode, projectName); }
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)); } })); }
protected override async Task Context() { await base.Context(); _simulationRunOptions = new SimulationRunOptions(); _simulation = A.Fake <IndividualSimulation>(); A.CallTo(() => _entityTask.Validate(_simulation)).Returns(true); }
public override void GlobalContext() { base.GlobalContext(); _compound = DomainFactoryForSpecs.CreateStandardCompound(); _individual = DomainFactoryForSpecs.CreateStandardIndividual(); _protocol = DomainFactoryForSpecs.CreateStandardIVBolusProtocol(); _globalPKAnalysisTask = IoC.Resolve <IGlobalPKAnalysisTask>(); _simulationRunOptions = new SimulationRunOptions(); }
public async Task <SimulationExport> ExportSimulation(Simulation simulation, ExportRunOptions exportRunOptions, PKSimProject project) { var projectName = project.Name; var simulationName = simulation.Name; var simulationFolder = Path.Combine(exportRunOptions.OutputFolder, FileHelper.RemoveIllegalCharactersFrom(simulationName)); DirectoryHelper.CreateDirectory(simulationFolder); var simulationExport = new SimulationExport { Project = projectName, SimulationFolder = simulationFolder, Simulation = simulationName }; var simulationRunOptions = new SimulationRunOptions(); _lazyLoadTask.Load(simulation); _lazyLoadTask.LoadResults(simulation); var simulationExportOptions = new SimulationExportOptions { OutputFolder = simulationFolder, ExportMode = exportRunOptions.ExportMode, ProjectName = projectName, }; if (!simulation.OutputSelections.HasSelection) { _logger.AddWarning($"Simulation '{simulationName}' does not have any selected output and will not be exported", projectName); return(simulationExport); } if (exportRunOptions.RunSimulation) { await _simulationExporter.RunAndExport(simulation, simulationRunOptions, simulationExportOptions); } else if (simulation.HasResults) { await _simulationExporter.Export(simulation, simulationExportOptions); } else { _logger.AddWarning($"Simulation '{simulationName}' does not have any results and will not be exported", projectName); return(simulationExport); } _logger.AddDebug($"Simulation '{simulationName}' exported to '{simulationFolder}'", projectName); return(simulationExport); }
protected override async Task Context() { await base.Context(); _populationSimulation = A.Fake <PopulationSimulation>(); _modelSimulation = A.Fake <IModelCoreSimulation>(); _populationData = A.Fake <DataTable>(); _runResults = new PopulationRunResults(); _simulationRunOptions = new SimulationRunOptions(); A.CallTo(() => _popExportTask.CreatePopulationDataFor(_populationSimulation, A <bool> ._)).Returns(_populationData); A.CallTo(() => _simMapper.MapFrom(_populationSimulation, false)).Returns(_modelSimulation); A.CallTo(() => _populationRunner.RunPopulationAsync(_modelSimulation, _populationData, A <DataTable> ._, A <DataTable> ._)).Returns(_runResults); }
public JsonSimulationRunner( ISimulationExporter simulationExporter, IOSPSuiteLogger logger, ISnapshotTask snapshotTask ) { _simulationExporter = simulationExporter; _logger = logger; _snapshotTask = snapshotTask; _simulationRunOptions = new SimulationRunOptions { Validate = false, CheckForNegativeValues = false, }; }
public InteractiveSimulationRunner(ISimulationSettingsRetriever simulationSettingsRetriever, ISimulationRunner simulationRunner, ICloner cloner, ISimulationAnalysisCreator simulationAnalysisCreator) { _simulationSettingsRetriever = simulationSettingsRetriever; _simulationRunner = simulationRunner; _cloner = cloner; _simulationAnalysisCreator = simulationAnalysisCreator; _simulationRunOptions = new SimulationRunOptions { CheckForNegativeValues = true, RaiseEvents = true, RunForAllOutputs = false, SimModelExportMode = SimModelExportMode.Optimized }; }
protected override Task Context() { _simulationEngine = A.Fake <IIndividualSimulationEngine>(); _popSimulationEngine = A.Fake <IPopulationSimulationEngine>(); _simulationEngineFactory = A.Fake <ISimulationEngineFactory>(); _simulationPersistableUpdater = A.Fake <ISimulationPersistableUpdater>(); _lazyLoadTask = A.Fake <ILazyLoadTask>(); _entityTask = A.Fake <IEntityValidationTask>(); A.CallTo(() => _simulationEngineFactory.Create <PopulationSimulation, PopulationRunResults>()).Returns(_popSimulationEngine); A.CallTo(() => _simulationEngineFactory.Create <IndividualSimulation, SimulationRunResults>()).Returns(_simulationEngine); sut = new SimulationRunner(_simulationEngineFactory, _lazyLoadTask, _entityTask, _simulationPersistableUpdater); _simulationRunOptions = new SimulationRunOptions(); return(_completed); }
protected override Task Context() { _simModelManager = A.Fake <ISimModelManager>(); _progressUpdater = A.Fake <IProgressUpdater>(); _progressManager = A.Fake <IProgressManager>(); _eventPublisher = A.Fake <IEventPublisher>(); _simulationResultsSynchronizer = A.Fake <ISimulationResultsSynchronizer>(); _modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>(); sut = new IndividualSimulationEngine(_simModelManager, _progressManager, _simulationResultsSynchronizer, _eventPublisher, _modelCoreSimulationMapper); A.CallTo(() => _progressManager.Create()).Returns(_progressUpdater); _simulationRunOption = new SimulationRunOptions { RaiseEvents = true }; return(_completed); }
public override void GlobalContext() { base.GlobalContext(); _compound = DomainFactoryForSpecs.CreateStandardCompound().WithName("Parent"); _metabolite = DomainFactoryForSpecs.CreateStandardCompound().WithName("Metabolite"); _individual = DomainFactoryForSpecs.CreateStandardIndividual(); _protocol = DomainFactoryForSpecs.CreateStandardIVBolusProtocol(); _cyp3A4 = AddEnzymeTo(_individual, "CYP3A4"); _parentMetabolizationCYP3A4 = AddEnzymaticProcess(_compound, _cyp3A4); _cyp2D6 = AddEnzymeTo(_individual, "CYP2D6"); _parentMetabolizationCYP2D6 = AddEnzymaticProcess(_compound, _cyp2D6); _simulationRunOptions = new SimulationRunOptions { RaiseEvents = false }; }
public async Task <SimulationMapping> ExportSimulation(Simulation simulation, ExportRunOptions exportRunOptions, PKSimProject project) { var projectName = project.Name; var simulationName = simulation.Name; var simulationFile = FileHelper.RemoveIllegalCharactersFrom(simulationName); var simulationFolder = Path.Combine(exportRunOptions.OutputFolder, simulationFile); DirectoryHelper.CreateDirectory(simulationFolder); var simulationExport = new SimulationMapping { Project = projectName, Path = simulationFolder, Simulation = simulationName, SimulationFile = simulationFile }; var simulationRunOptions = new SimulationRunOptions(); _lazyLoadTask.Load(simulation); _lazyLoadTask.LoadResults(simulation); var simulationExportOptions = new SimulationExportOptions { OutputFolder = simulationFolder, ExportMode = exportRunOptions.ExportMode, ProjectName = projectName, }; if (exportRunOptions.RunSimulation) { await _simulationExporter.RunAndExport(simulation, simulationRunOptions, simulationExportOptions); } else { await _simulationExporter.Export(simulation, simulationExportOptions); } _logger.AddDebug($"Simulation '{simulationName}' exported to '{simulationFolder}'", projectName); return(simulationExport); }
public override void GlobalContext() { base.GlobalContext(); _compound = DomainFactoryForSpecs.CreateStandardCompound(); _individual = DomainFactoryForSpecs.CreateStandardIndividual(); _protocol = DomainFactoryForSpecs.CreateStandardIVBolusProtocol(); var cmRepo = IoC.Resolve <ICalculationMethodRepository>(); var intestinalPermGroup = _compound.ParameterAlternativeGroup(CoreConstants.Groups.COMPOUND_INTESTINAL_PERMEABILITY); var paramAlternativeFactory = IoC.Resolve <IParameterAlternativeFactory>(); var alternative = paramAlternativeFactory.CreateAlternativeFor(intestinalPermGroup).WithName(_intestinalPermAlternativeName); intestinalPermGroup.AddAlternative(alternative); _intestinalPermeabilityCalcMethods = cmRepo.Where(cm => cm.Category.Equals(CoreConstants.Category.IntestinalPermeability)).ToList(); _alternativeIntestinalPermParam = alternative.Parameter(CoreConstants.Parameters.SPECIFIC_INTESTINAL_PERMEABILITY); _simulationEngine = IoC.Resolve <IIndividualSimulationEngine>(); _simulationRunOptions = new SimulationRunOptions(); }
public Task RunSimulation(Simulation simulation, SimulationRunOptions simulationRunOptions = null) { _simulationRunOptions = simulationRunOptions ?? new SimulationRunOptions(); _lazyLoadTask.Load(simulation); if (_simulationRunOptions.Validate && !_entityValidationTask.Validate(simulation)) { return(_simulationDidNotRun); } switch (simulation) { case IndividualSimulation individualSimulation: return(runSimulation(individualSimulation, _simulationPersistableUpdater.UpdatePersistableFromSettings)); case PopulationSimulation populationSimulation: return(runSimulation(populationSimulation, _simulationPersistableUpdater.UpdatePersistableFromSettings)); } return(_simulationDidNotRun); }
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 RunAsync(PopulationSimulation populationSimulation, SimulationRunOptions simulationRunOptions) { _progressUpdater = _progressManager.Create(); _progressUpdater.Initialize(populationSimulation.NumberOfItems, PKSimConstants.UI.Calculating); _populationRunner.NumberOfCoresToUse = _userSettings.MaximumNumberOfCoresToUse; var begin = SystemTime.UtcNow(); try { var populationData = _populationExporter.CreatePopulationDataFor(populationSimulation); var modelCoreSimulation = _modelCoreSimulationMapper.MapFrom(populationSimulation, shouldCloneModel: false); _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) { simulationTerminated(); throw; } finally { var end = SystemTime.UtcNow(); var timeSpent = end - begin; _eventPublisher.PublishEvent(new SimulationRunFinishedEvent(populationSimulation, timeSpent)); } }