private SimulationExport createSimulationExport(IModelCoreSimulation simulation, SimModelExportMode simModelExportMode) { var simulationExport = _createExportModelVisitor.CreateExportFor(simulation.Model, simModelExportMode); simulationExport.AddSimulationConfiguration(simulation.BuildConfiguration.SimulationSettings); return(simulationExport); }
public override void GlobalContext() { base.GlobalContext(); _simulation = _simulationPersister.LoadSimulation(HelperForSpecs.DataFile("S1.pkml")); _concurrentRunSimulationBatch = new ConcurrentRunSimulationBatch ( _simulation, new SimulationBatchOptions { VariableMolecules = new[] { new[] { "Organism", "Kidney", "Intracellular", "Caffeine" }.ToPathString() }, VariableParameters = new[] { new[] { "Organism", "Liver", "Volume" }.ToPathString(), new[] { "Organism", "Hematocrit" }.ToPathString(), } } ); sut.AddSimulationBatch(_concurrentRunSimulationBatch); }
public override void GlobalContext() { base.GlobalContext(); _objectPathFactory = IoC.Resolve <IObjectPathFactory>(); _modelCoreSimulation = IoC.Resolve <SimulationHelperForSpecs>().CreateSimulation(); var simModelExporter = IoC.Resolve <ISimModelExporter>(); var simModelSimulationFactory = A.Fake <ISimModelSimulationFactory>(); A.CallTo(() => simModelSimulationFactory.Create()).Returns(new Simulation()); _simModelManagerForSpecs = new SimModelManagerForSpecs(simModelExporter, simModelSimulationFactory); _simModelSimulation = _simModelManagerForSpecs.CreateSimulation(_modelCoreSimulation); _dataFactory = A.Fake <IDataFactory>(); _variableParameterPaths = new[] { _objectPathFactory.CreateObjectPathFrom(ConstantsForSpecs.Organism, ConstantsForSpecs.BW).PathAsString, _objectPathFactory.CreateObjectPathFrom(ConstantsForSpecs.Organism, ConstantsForSpecs.TableParameter1).PathAsString, }; _variableSpeciesPath = new [] { _objectPathFactory.CreateObjectPathFrom(ConstantsForSpecs.Organism, ConstantsForSpecs.ArterialBlood, ConstantsForSpecs.Plasma, "A").PathAsString, _objectPathFactory.CreateObjectPathFrom(ConstantsForSpecs.Organism, ConstantsForSpecs.VenousBlood, ConstantsForSpecs.Plasma, "B").PathAsString, }; sut = new SimModelBatch(simModelExporter, simModelSimulationFactory, _dataFactory); }
public override void GlobalContext() { base.GlobalContext(); _simulation = LoadPKMLFile("simple_IV_53").Simulation; _simulationConfiguration = _simulation.BuildConfiguration; _dimensionFactory = IoC.Resolve <IDimensionFactory>(); }
private SimulationResults runSimulation(IModelCoreSimulation simulation, CancellationToken cancellationToken) { //We want a new instance every time that's why we are not injecting SimulationRunner in constructor return(Api.GetSimulationRunner().Run(new SimulationRunArgs { Simulation = simulation, SimulationRunOptions = SimulationRunOptions })); }
protected override void Context() { base.Context(); _pkAnalysis = new PopulationSimulationPKAnalyses(); _populationSimulation = A.Fake <IModelCoreSimulation>(); var quantityPKParameter = new QuantityPKParameter { QuantityPath = "Liver", Name = "P" }; var pkParameter = new PKParameter { DisplayUnit = "UNIT", Name = "P" }; A.CallTo(() => _pkParameterRepository.FindByName(quantityPKParameter.Name)).Returns(pkParameter); var mergedDimension = A.Fake <IDimension>(); quantityPKParameter.SetValue(0, 10); quantityPKParameter.SetValue(1, 11); A.CallTo(() => _dimensionFactory.MergedDimensionFor(A <QuantityPKParameterContext> ._)) .WhenArgumentsMatch(x => x.Get <QuantityPKParameterContext>(0).QuantityPKParameter == quantityPKParameter) .Returns(mergedDimension); var unit = A.Fake <Unit>(); A.CallTo(() => unit.Name).Returns(pkParameter.DisplayUnit); A.CallTo(() => mergedDimension.UnitOrDefault(pkParameter.DisplayUnit)).Returns(unit); A.CallTo(() => mergedDimension.BaseUnitValueToUnitValue(unit, 10)).Returns(100.10f); A.CallTo(() => mergedDimension.BaseUnitValueToUnitValue(unit, 11)).Returns(110.20f); _pkAnalysis.AddPKAnalysis(quantityPKParameter); }
protected override void Context() { _dataFactory = A.Fake <IDataFactory>(); _simModelExporter = A.Fake <ISimModelExporter>(); _simModelSimulationFactory = A.Fake <ISimModelSimulationFactory>(); _simModelSimulation = A.Fake <ISimulation>(); sut = new SimModelBatch(_simModelExporter, _simModelSimulationFactory, _dataFactory); A.CallTo(() => _simModelSimulationFactory.Create()).Returns(_simModelSimulation); _modelCoreSimulation = A.Fake <IModelCoreSimulation>(); _simModelXmlString = "SimModelXml"; A.CallTo(() => _simModelExporter.Export(_modelCoreSimulation, SimModelExportMode.Optimized)).Returns(_simModelXmlString); _parameterProperties1 = A.Fake <IParameterProperties>(); _parameterProperties2 = A.Fake <IParameterProperties>(); _parameterProperties3 = A.Fake <IParameterProperties>(); A.CallTo(() => _parameterProperties1.Path).Returns("ParameterPath1"); A.CallTo(() => _parameterProperties2.Path).Returns("ParameterPath2"); A.CallTo(() => _parameterProperties3.Path).Returns("ParameterPath3"); _allSimModelParameters = new List <IParameterProperties> { _parameterProperties1, _parameterProperties2, _parameterProperties3 }; A.CallTo(() => _simModelSimulation.ParameterProperties).Returns(_allSimModelParameters); _variableParameterPaths = new List <string> { _parameterProperties1.Path, _parameterProperties2.Path }; }
public async Task <SimulationResultsImport> ImportResults(IModelCoreSimulation simulation, IReadOnlyCollection <string> files, CancellationToken cancellationToken, bool showImportProgress = true) { using (var progressUpdater = showImportProgress ? _progressManager.Create() : new NoneProgressUpdater()) { progressUpdater.Initialize(files.Count, Messages.ImportingResults); // Use ToList to execute the query and start the import task. var tasks = files.Select(f => importFiles(f, simulation, cancellationToken)).ToList(); var allImportedResults = new List <IndividualResultsImport>(); // Await the completion of all the running tasks. // Add a loop to process the tasks one at a time until none remain. while (tasks.Count > 0) { cancellationToken.ThrowIfCancellationRequested(); // Identify the first task that completes. var firstFinishedTask = await Task.WhenAny(tasks); // Remove the selected task from the list so that you don't // process it more than once. tasks.Remove(firstFinishedTask); // Await the completed task. allImportedResults.Add(await firstFinishedTask); progressUpdater.IncrementProgress(); } //once all results have been imported, it is time to ensure that they are consistent var results = createSimulationResultsFrom(allImportedResults, simulation); addImportedQuantityToLogForSuccessfulImport(results); return(results); } }
protected override void Context() { base.Context(); _simulation = IoC.Resolve <SimulationHelperForSpecs>().CreateSimulation(); _tempFolderFormulas = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); _tempFolderValues = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); }
public SimulationBatch Create(IModelCoreSimulation modelCoreSimulation, SimulationBatchOptions simulationBatchOptions) { var simulationBatch = Create(); simulationBatch.Initialize(modelCoreSimulation, simulationBatchOptions); return(simulationBatch); }
private SimulationResults run(IModelCoreSimulation simulation, SimulationRunOptions simulationRunOptions) { _simulationPersistableUpdater.UpdateSimulationPersistable(simulation); var simulationResults = _simModelManager.RunSimulation(simulation, coreSimulationRunOptionsFrom(simulationRunOptions)); return(_simulationResultsCreator.CreateResultsFrom(simulationResults.Results)); }
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(); } }
public static IReadOnlyList <ApplicationParameters> AllApplicationParametersOrderedByStartTimeForQuantityPath( this IModelCoreSimulation simulation, string quantityPath) { var moleculeName = simulation.Model?.MoleculeNameFor(quantityPath); return(AllApplicationParametersOrderedByStartTimeFor(simulation, moleculeName)); }
public void Clear() { _modelCoreSimulation = null; _simModelSimulation = null; _parameterValueCache.Clear(); _allVariableParameters.Clear(); }
protected override void Context() { base.Context(); _model = A.Fake <IModel>().WithName("Test"); _modelCoreSimulation = A.Fake <IModelCoreSimulation>().WithName("Test"); A.CallTo(() => _modelCoreSimulation.Model).Returns(_model); }
public SensitivityAnalysisRunResult ImportResultsFromCSV(IModelCoreSimulation simulation, params string[] csvFiles) { var sensitivityAnalysisImportResult = _sensitivityAnalysisRunResultsImportTask.ImportResults(simulation, csvFiles, CancellationToken.None, showImportProgress: false).Result; sensitivityAnalysisImportResult.ThrowOnError(); _logger.Log(sensitivityAnalysisImportResult); return(sensitivityAnalysisImportResult.SensitivityAnalysisRunResult); }
protected override void Context() { _simulation = A.Fake <IModelCoreSimulation>(); _dimensionFactory = new DimensionFactoryForIntegrationTests(); _dimensionFactory.AddDimension(DomainHelperForSpecs.TimeDimensionForSpecs()); _dimensionFactory.AddDimension(DomainHelperForSpecs.ConcentrationDimensionForSpecs()); sut = new SimulationPKAnalysesImporter(_dimensionFactory); }
private static bool changeUsagesInSumulation(string newName, IModelCoreSimulation simulation, ICommandCollector commandCollector) { commandCollector.AddCommand(new RenameObjectBaseCommand(simulation.Model, newName, null)); commandCollector.AddCommand(new RenameModelCommand(simulation.Model, newName)); // Dont rename core Container to avoid refernce Corruption return(true); }
private SimulationExport createSimulationExport(IModelCoreSimulation simulation, SimModelExportMode simModelExportMode) { var simulationExportCreator = _simulationExportCreatorFactory.Create(); var simulationExport = simulationExportCreator.CreateExportFor(simulation.Model, simModelExportMode); simulationExport.AddSimulationConfiguration(simulation.SimulationSettings); return(simulationExport); }
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() { sut = Api.GetSimulationResultsTask(); _simulationPersister = Api.GetSimulationPersister(); var simulationFile = HelperForSpecs.DataFile("S1.pkml"); _simulation = _simulationPersister.LoadSimulation(simulationFile); }
public void InitializeWith(IModelCoreSimulation modelCoreSimulation, IReadOnlyList <string> variableParameterPaths, IReadOnlyList <string> variableMoleculePaths, bool calculateSensitivities = false, string simulationResultsName = null) { _modelCoreSimulation = modelCoreSimulation; _simulationResultsName = simulationResultsName; _calculateSensitivities = calculateSensitivities; _simModelSimulation = createAndFinalizeSimulation(variableParameterPaths, variableMoleculePaths); }
public override void GlobalContext() { base.GlobalContext(); _withIdRepository = IoC.Resolve <IWithIdRepository>(); _simulation = IoC.Resolve <SimulationHelperForSpecs>().CreateSimulation(); new RegisterTaskForSpecs(_withIdRepository).RegisterAllIn(_simulation.Model.Root); sut = IoC.Resolve <ISimModelManager>(); }
protected override void Context() { base.Context(); _simulationRunResults = new SimulationRunResults(true, Enumerable.Empty <SolverWarning>(), DomainHelperForSpecs.IndividualSimulationDataRepositoryFor("Sim")); _simulation = new ModelCoreSimulation(); A.CallTo(_simModelManager).WithReturnType <SimulationRunResults>().Returns(_simulationRunResults); }
protected virtual void Cleanup() { _modelCoreSimulation = null; _simModelSimulation?.Dispose(); _simModelSimulation = null; _parameterValueCache.Clear(); _initialValueCache.Clear(); }
private void validateConsistencyWithSimulation(IModelCoreSimulation simulation, SimulationPKParametersImport importedPKParameter) { var allQuantities = _entitiesInSimulationRetriever.OutputsFrom(simulation); foreach (var pkParameter in importedPKParameter.PKParameters) { verifyThatQuantityExistsInSimulation(allQuantities, pkParameter, importedPKParameter); } }
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); }
protected override void Context() { _simulationPersistableUpdater = A.Fake <ISimulationPersistableUpdater>(); sut = new OutputSelectionUpdater(_simulationPersistableUpdater); _mappedOutputs = new List <QuantitySelection>(); _simulation = A.Fake <IModelCoreSimulation>(); _outputSelection = new OutputSelections(); _simulation.SimulationSettings.OutputSelections = _outputSelection; }
private DataRepository getResults(IModelCoreSimulation simulation) { if (_canceled) { return(new DataRepository()); } return(_dataFactory.CreateRepository(simulation, _simModelSimulation)); }
public void ConvertDimensionIn(IModelCoreSimulation simulation) { convertDimensionIn(simulation.Model.Root, convertFormulasAtParameter: true); if (simulation.BuildConfiguration.SimulationSettings == null) { return; } convertDimensionIn(simulation.BuildConfiguration.SimulationSettings.OutputSchema, convertFormulasAtParameter: true); }