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);
}
