示例#1
0
        protected override void ExecuteWith(IExecutionContext context)
        {
            var quantitiesRetriever = context.Resolve <IEntitiesInContainerRetriever>();
            var quantityCache       = quantitiesRetriever.QuantitiesFrom(_populationSimulation);

            //create settings based on import
            _populationSimulation.OutputSelections.Clear();
            foreach (var quantityPath in _simulationResults.AllQuantityPaths())
            {
                var quantity = quantityCache[quantityPath];
                if (quantity != null)
                {
                    _populationSimulation.OutputSelections.AddOutput(new QuantitySelection(quantityPath, quantity.QuantityType));
                }
            }

            //set results
            _populationSimulation.Results = _simulationResults;

            //last but not least, create pk analyses results.
            var populationPKAnalysesTask = context.Resolve <IPopulationPKAnalysesTask>();

            _populationSimulation.PKAnalyses = populationPKAnalysesTask.CalculateFor(_populationSimulation);

            context.UpdateBuildinBlockProperties(this, _populationSimulation);
            context.PublishEvent(new SimulationResultsUpdatedEvent(_populationSimulation));
        }
        public DataTable ResultsToDataTable(SimulationResults simulationResults, IModelCoreSimulation simulation)
        {
            //Id	Time	Output1	Output2	...	OutputN
            var dataTable = new DataTable();

            var allQuantities     = _quantityRetriever.QuantitiesFrom(simulation);
            var timeColumnName    = Constants.NameWithUnitFor(TIME, _timeDimension.BaseUnit);
            var quantityPathCache = new Cache <string, string>();

            dataTable.AddColumn <int>(INDIVIDUAL_ID);
            dataTable.AddColumn <string>(timeColumnName);

            if (simulationResults.IsNull())
            {
                return(dataTable);
            }

            var allQuantityPaths = simulationResults.AllQuantityPaths();

            foreach (var quantityPath in allQuantityPaths)
            {
                var quantity = allQuantities[quantityPath];
                if (quantity == null)
                {
                    continue;
                }

                //export results in base unit so that they can be computed automatically from matlab scripts
                quantityPathCache[quantityPath] = Constants.NameWithUnitFor(quantityPath, quantity.Dimension.BaseUnit);
                dataTable.AddColumn <string>(quantityPathCache[quantityPath]);
            }

            dataTable.BeginLoadData();
            int numberOfValues = simulationResults.Time.Length;

            foreach (var individualResults in simulationResults.OrderBy(x => x.IndividualId))
            {
                var allQuantitiesCache = new Cache <string, QuantityValues>(x => x.QuantityPath);
                allQuantitiesCache.AddRange(individualResults);

                for (int i = 0; i < numberOfValues; i++)
                {
                    var row = dataTable.NewRow();
                    row[INDIVIDUAL_ID]  = individualResults.IndividualId;
                    row[timeColumnName] = simulationResults.Time[i].ConvertedTo <string>();

                    foreach (var quantityPath in allQuantityPaths)
                    {
                        var quantity = allQuantities[quantityPath];
                        if (quantity == null)
                        {
                            continue;
                        }

                        row[quantityPathCache[quantityPath]] = allQuantitiesCache[quantityPath][i].ConvertedTo <string>();
                    }

                    dataTable.Rows.Add(row);
                }
            }

            dataTable.EndLoadData();
            return(dataTable);
        }