private async Task <SimulationResults> runAsync(
            IModelCoreSimulation simulation,
            IndividualValuesCache population,
            AgingData agingData = null,
            SimulationRunOptions simulationRunOptions = null)
        {
            var options = simulationRunOptions ?? new SimulationRunOptions();

            initializeProgress(options);
            _simulationPersistableUpdater.UpdateSimulationPersistable(simulation);
            try
            {
                var populationRunResults = await _populationRunner.RunPopulationAsync(
                    simulation,
                    options,
                    populationData : _populationTask.PopulationTableFrom(population, simulation),
                    agingData : agingData?.ToDataTable()
                    );

                return(populationRunResults.Results);
            }
            finally
            {
                simulationTerminated();
            }
        }
        private SimulationResults run(IModelCoreSimulation simulation, SimulationRunOptions simulationRunOptions)
        {
            _simulationPersistableUpdater.UpdateSimulationPersistable(simulation);
            var simulationResults = _simModelManager.RunSimulation(simulation, coreSimulationRunOptionsFrom(simulationRunOptions));

            return(_simulationResultsCreator.CreateResultsFrom(simulationResults.Results));
        }
 public void Deconstruct(out IModelCoreSimulation simulation, out IndividualValuesCache population, out AgingData agingData,
                         out SimulationRunOptions simulationRunOptions)
 {
     simulation           = Simulation;
     simulationRunOptions = SimulationRunOptions;
     population           = Population;
     agingData            = AgingData;
 }
 protected override void Context()
 {
     base.Context();
     _simulation           = new ModelCoreSimulation();
     _population           = new IndividualValuesCache();
     _populationData       = new DataTable();
     _simulationRunOptions = new SimulationRunOptions();
     A.CallTo(() => _populationTask.PopulationTableFrom(_population, _simulation)).Returns(_populationData);
 }
        private Core.Domain.SimulationRunOptions coreSimulationRunOptionsFrom(SimulationRunOptions simulationRunOptions)
        {
            var options = simulationRunOptions ?? new SimulationRunOptions();

            return(new Core.Domain.SimulationRunOptions
            {
                CheckForNegativeValues = options.CheckForNegativeValues,
                SimModelExportMode = SimModelExportMode.Optimized
            });
        }
        protected override void Context()
        {
            base.Context();
            _simulation           = new ModelCoreSimulation();
            _population           = new IndividualValuesCache();
            _populationData       = new DataTable();
            _simulationRunOptions = new SimulationRunOptions();
            _agingData            = new AgingData
            {
                IndividualIds  = new[] { 0, 1 },
                ParameterPaths = new[] { "Organism|Liver|Volume", "Organism|Liver|Volume" },
                Times          = new[] { 10, 20.0 },
                Values         = new[] { 4.0, 5.0 },
            };

            A.CallTo(() => _populationTask.PopulationTableFrom(_population, _simulation)).Returns(_populationData);
        }
 private Task <SimulationResults> runAsync(IModelCoreSimulation simulation, SimulationRunOptions simulationRunOptions)
 {
     return(Task.Run(() => run(simulation, simulationRunOptions)));
 }
 private void initializeProgress(SimulationRunOptions options)
 {
     _populationRunner.Terminated         += terminated;
     _populationRunner.SimulationProgress += simulationProgress;
     _progressUpdater = options.ShowProgress ? _progressManager.Create() : new NoneProgressUpdater();
 }