public override string Communicate(ParameterIdentification pid, int timeout = 300)
{
// check if the header needs to be set
if (pid.Header != currentJ1850Header &&
!string.IsNullOrEmpty(pid.Header))
{
string response = SendCommand(Protocols.Elm327.SetFrameHeader(pid.Header));
if (!response.Contains(Protocols.Elm327.Responses.OK))
{
Diagnostics.DiagnosticLogger.Log("Could not set frame header for PID" + System.Environment.NewLine + pid.ToString());
return(null);
}
}
else if (string.IsNullOrEmpty(pid.Header))
{
string response = SendCommand(Protocols.Elm327.SetFrameHeader(Protocols.J1850.Headers.Default));
if (!response.Contains(Protocols.Elm327.Responses.OK))
{
Diagnostics.DiagnosticLogger.Log("Could not set default frame header for PID" + System.Environment.NewLine + pid.ToString());
return(null);
}
}
return(pid.SimulatedResponse(this.Protocol));
}
private void randomizeStartValuesFor(ParameterIdentification parameterIdentification)
{
parameterIdentification.AllVariableIdentificationParameters.Each(x =>
{
x.StartValueParameter.Value = generatedRandomStartValueFor(x);
});
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationSimulationSelectionView>();
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_applicationController = A.Fake <IApplicationController>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_treeNodeContextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>();
_dialogCreator = A.Fake <IDialogCreator>();
_parameterIdentificationTask = A.Fake <IParameterIdentificationTask>();
sut = new ParameterIdentificationSimulationSelectionPresenter(_view, _treeNodeFactory, _applicationController, _lazyLoadTask, _treeNodeContextMenuFactory,
_multipleTreeNodeContextMenuFactory, _dialogCreator, _parameterIdentificationTask);
_parameterIdentification = new ParameterIdentification();
_simulation = A.Fake <ISimulation>().WithId("Id").WithName("S");
_parameterIdentification.AddSimulation(_simulation);
_outputMapping = new OutputMapping
{
OutputSelection = new SimulationQuantitySelection(_simulation, new QuantitySelection("PATH", QuantityType.Drug))
};
_parameterIdentification.AddOutputMapping(_outputMapping);
_simulationNode = A.Fake <ITreeNode>();
A.CallTo(() => _treeNodeFactory.CreateFor(_simulation)).Returns(_simulationNode);
_simulationSelectionPresenter = A.Fake <ISelectionSimulationPresenter>();
A.CallTo(() => _applicationController.Start <ISelectionSimulationPresenter>()).Returns(_simulationSelectionPresenter);
sut.EditParameterIdentification(_parameterIdentification);
}
protected override void Context()
{
base.Context();
_parameterIdentification = new ParameterIdentification();
_parameterIdentification.Configuration.AlgorithmProperties = new OptimizationAlgorithmProperties("XX");
_parameterIdentification.AddIdentificationParameter(DomainHelperForSpecs.IdentificationParameter());
}
protected override void Context()
{
base.Context();
_runResult.BestResult = new OptimizationRunResult();
_runResult.BestResult.AddValue(new OptimizedParameterValue("Does not exist", 1, 1));
_parameterIdentification = new ParameterIdentification();
}
protected void FindMissingOutputPaths(ParameterIdentification parameterIdentification, ISimulation oldSimulation, ISimulation newSimulation)
{
var outputMappings = parameterIdentification.AllOutputMappingsFor(oldSimulation);
outputMappings.Where(outputMapping => !simulationHasEquivalentPath(outputMapping.OutputPath, newSimulation)).ToList().Each(outputPath =>
ActionForSimulationDoesNotHaveOutputPath(parameterIdentification, newSimulation, outputPath));
}
protected override void Context()
{
_optimizationAlgorithm1 = A.Fake <IOptimizationAlgorithm>();
_optimizationAlgorithm2 = A.Fake <IOptimizationAlgorithm>();
A.CallTo(() => _optimizationAlgorithm2.Name).Returns(Constants.OptimizationAlgorithm.DEFAULT);
_identificationAlgorithm1 = A.Fake <OptimizationAlgorithmProperties>();
_identificationAlgorithm2 = A.Fake <OptimizationAlgorithmProperties>();
_algorithmPropertiesMapper = A.Fake <IOptimizationAlgorithmToOptimizationAlgorithmPropertiesMapper>();
_parameterIdentificationConfigurationDTOMapper = A.Fake <IParameterIdentificationConfigurationToParameterIdentificationConfigurationDTOMapper>();
_optimizationAlgorithmRepository = A.Fake <IOptimizationAlgorithmRepository>();
_parameterIdentificationAlgorithmOptionsPresenter = A.Fake <IExtendedPropertiesPresenter>();
_view = A.Fake <IParameterIdentificationConfigurationView>();
_parameterIdentification = new ParameterIdentification();
_noOptionsPresenter = A.Fake <IStandardParameterIdentificationRunModePresenter>();
_multipleParameterIdentificationRunModePresenter = A.Fake <IMultipleParameterIdentificationRunModePresenter>();
_categorialParameterIdentificationRunModePresenter = A.Fake <ICategorialParameterIdentificationRunModePresenter>();
ConfigureCategorialParameterIdentificationRunModePresenter();
sut = new ParameterIdentificationConfigurationPresenter(_view, _parameterIdentificationAlgorithmOptionsPresenter, _optimizationAlgorithmRepository, _parameterIdentificationConfigurationDTOMapper, _algorithmPropertiesMapper,
_noOptionsPresenter, _multipleParameterIdentificationRunModePresenter, _categorialParameterIdentificationRunModePresenter);
A.CallTo(() => _algorithmPropertiesMapper.MapFrom(_optimizationAlgorithm1)).Returns(_identificationAlgorithm1);
A.CallTo(() => _algorithmPropertiesMapper.MapFrom(_optimizationAlgorithm2)).Returns(_identificationAlgorithm2);
A.CallTo(() => _noOptionsPresenter.CanEdit(A <ParameterIdentification> .That.Matches(x => x.Configuration.RunMode.IsAnImplementationOf <StandardParameterIdentificationRunMode>()))).Returns(true);
A.CallTo(() => _categorialParameterIdentificationRunModePresenter.CanEdit(A <ParameterIdentification> .That.Matches(x => x.Configuration.RunMode.IsAnImplementationOf <CategorialParameterIdentificationRunMode>()))).Returns(true);
A.CallTo(() => _multipleParameterIdentificationRunModePresenter.CanEdit(A <ParameterIdentification> .That.Matches(x => x.Configuration.RunMode.IsAnImplementationOf <MultipleParameterIdentificationRunMode>()))).Returns(true);
}
protected override void Context()
{
_executionContext = A.Fake <IOSPSuiteExecutionContext>();
_eventPublisher = A.Fake <IEventPublisher>();
_project = A.Fake <IProject>();
_parameterIdentification = new ParameterIdentification();
_applicationController = A.Fake <IApplicationController>();
_renameObjectPresenter = A.Fake <IRenameObjectPresenter>();
A.CallTo(() => _applicationController.Start <IRenameObjectPresenter>()).Returns(_renameObjectPresenter);
A.CallTo(() => _executionContext.Project).Returns(_project);
A.CallTo(() => _renameObjectPresenter.NewNameFrom(_parameterIdentification, A <IEnumerable <string> > ._, A <string> ._)).Returns("newName");
A.CallTo(() => _project.AllParameterIdentifications).Returns(new[]
{
new ParameterIdentification {
Name = "name1"
},
new ParameterIdentification {
Name = "name2"
}
});
sut = new RenameParameterIdentificationUICommand(_executionContext, _eventPublisher, _applicationController);
sut.For(_parameterIdentification);
}
public async Task Run(ParameterIdentification parameterIdentification)
{
if (!_entityValidationTask.Validate(parameterIdentification))
{
return;
}
try
{
if (IsRunning)
{
throw new OSPSuiteException(Error.CannotStartTwoConcurrentParameterIdentifications);
}
using (_parameterIdentificationEngine = _parameterIdentificationEngineFactory.Create())
{
var begin = SystemTime.UtcNow();
await _parameterIdentificationEngine.StartAsync(parameterIdentification);
var end = SystemTime.UtcNow();
var timeSpent = end - begin;
_dialogCreator.MessageBoxInfo(Captions.ParameterIdentification.ParameterIdentificationFinished(timeSpent.ToDisplay()));
}
}
catch (OperationCanceledException)
{
_dialogCreator.MessageBoxInfo(Captions.ParameterIdentification.ParameterIdentificationCanceled);
}
finally
{
_executionContext.ProjectChanged();
_parameterIdentificationEngine = null;
}
}
protected override void Context()
{
base.Context();
_parameterIdentification = A.Fake <ParameterIdentification>();
sut.EditParameterIdentification(_parameterIdentification);
_errorHistory.AddRange(new[] { 10f, 11f, 12f });
}
public void Export(ParameterIdentification parameterIdentification, string fileName)
{
var serializer = _serializerRepository.SerializerFor(parameterIdentification);
var element = serializer.Serialize(parameterIdentification, new ParameterIdentificationExportSerializationContext());
XmlHelper.SaveXmlElementToFile(element, fileName);
}
protected override void Context()
{
_runResultDTOMapper = A.Fake <IParameterIdentificationRunResultToRunResultDTOMapper>();
_view = A.Fake <IMultipleParameterIdentificationResultsView>();
_transferOptimizedParametersToSimulationTask = A.Fake <ITransferOptimizedParametersToSimulationsTask>();
_commandCollector = A.Fake <ICommandCollector>();
sut = new MultipleParameterIdentificationResultsPresenter(_view, _runResultDTOMapper, _transferOptimizedParametersToSimulationTask);
sut.InitializeWith(_commandCollector);
_parameterIdentification = new ParameterIdentification();
_runResult1 = A.Fake <ParameterIdentificationRunResult>();
_runResult2 = A.Fake <ParameterIdentificationRunResult>();
_parameterIdentification.AddResult(_runResult1);
_parameterIdentification.AddResult(_runResult2);
_dto1 = new ParameterIdentificationRunResultDTO(_runResult1);
_dto2 = new ParameterIdentificationRunResultDTO(_runResult2);
A.CallTo(() => _runResultDTOMapper.MapFrom(_parameterIdentification, _runResult1)).Returns(_dto1);
A.CallTo(() => _runResultDTOMapper.MapFrom(_parameterIdentification, _runResult2)).Returns(_dto2);
A.CallTo(() => _view.BindTo(A <IEnumerable <ParameterIdentificationRunResultDTO> > ._))
.Invokes(x => _allParameterIdentificationRunResultDTO = x.GetArgument <IEnumerable <ParameterIdentificationRunResultDTO> >(0).ToList());
}
public ISimulationAnalysis CreateAnalysisFor(ParameterIdentification parameterIdentification, ParameterIdentificationAnalysisType parameterIdentificationAnalysisType)
{
switch (parameterIdentificationAnalysisType)
{
case ParameterIdentificationAnalysisType.TimeProfile:
return(createTimeProfileAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.ResidualsVsTime:
return(createResidualVsTimeAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.ResidualHistogram:
return(createHistogramAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.PredictedVsObserved:
return(createPredictedVsObservedAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.CorrelationMatrix:
return(createCorrelationAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.CovarianceMatrix:
return(createCovarianceAnalysisFor(parameterIdentification));
case ParameterIdentificationAnalysisType.TimeProfileConfidenceInterval:
return(createTimeProfileConfidenceInterval(parameterIdentification));
case ParameterIdentificationAnalysisType.TimeProfilePredictionInterval:
return(createTimeProfilePredictionInterval(parameterIdentification));
case ParameterIdentificationAnalysisType.TimeProfileVPCInterval:
return(createTimeProfileVPCInterval(parameterIdentification));
default:
throw new ArgumentOutOfRangeException(nameof(parameterIdentificationAnalysisType), parameterIdentificationAnalysisType, null);
}
}
private T createChartAnalysisFor <T>(ParameterIdentification parameterIdentification) where T : CurveChart, ISimulationAnalysis
{
var chart = _chartFactory.Create <T>();
AddSimulationAnalysisTo(parameterIdentification, chart);
return(chart);
}
private string getExportDirectory(ParameterIdentification parameterIdentification)
{
var path = _dialogCreator.AskForFolder(Captions.ParameterIdentification.SelectDirectoryForParameterIdentificationExport, Constants.DirectoryKey.SIM_MODEL_XML);
if (string.IsNullOrEmpty(path))
{
return(path);
}
var newDirectoryName = parameterIdentification.Name;
path = Path.Combine(path, newDirectoryName);
if (!DirectoryHelper.DirectoryExists(path))
{
return(DirectoryHelper.CreateDirectory(path));
}
if (_dialogCreator.MessageBoxYesNo(Captions.DoYouWantToDeleteDirectory(newDirectoryName), Captions.Delete, Captions.Cancel) == ViewResult.No)
{
return(string.Empty);
}
DirectoryHelper.DeleteDirectory(path, true);
return(DirectoryHelper.CreateDirectory(path));
}
protected override void Context()
{
base.Context();
_simulation = A.Fake <ISimulation>();
_parameterIdentification = A.Fake <ParameterIdentification>();
A.CallTo(() => _parameterIdentification.UsesSimulation(_simulation)).Returns(true);
}
protected void FindMissingObservedData(ParameterIdentification parameterIdentification, ISimulation oldSimulation, ISimulation newSimulation)
{
var mappingUsingSimulation = parameterIdentification.AllOutputMappingsFor(oldSimulation);
mappingUsingSimulation.Where(mapping => !newSimulation.UsesObservedData(mapping.WeightedObservedData.ObservedData)).ToList().Each(mapping =>
ActionForSimulationDoesNotUseObservedData(parameterIdentification, newSimulation, mapping));
}
private void updateResidualOutputsPaths(ParameterIdentification identification, string oldName, string newName)
{
if (identification.HasResults)
{
identification.Results.SelectMany(result => result.BestResult.AllOutputResiduals).Each(residual => updateOutputResidualPath(residual, oldName, newName));
}
}
protected override void Context()
{
_cloneManager = A.Fake <ICloneManagerForModel>();
_simulationFactory = A.Fake <ICoreSimulationFactory>();
_parameterIdentificationRun = A.Fake <IParameterIdentificationRun>();
_coreUserSettings = A.Fake <ICoreUserSettings>();
_descriptionCreator = A.Fake <ICategorialParameterIdentificationDescriptionCreator>();
_container = A.Fake <Utility.Container.IContainer>();
A.CallTo(() => _container.Resolve <ICoreSimulationFactory>()).Returns(_simulationFactory);
_coreUserSettings.MaximumNumberOfCoresToUse = 1;
sut = new CategorialParameterIdentificationRunInitializer(_cloneManager, _parameterIdentificationRun, _container, _descriptionCreator, _coreUserSettings);
_parameterIdentification = new ParameterIdentification();
_parameterIdentification.Configuration.RunMode = new CategorialParameterIdentificationRunMode();
_simulation = A.Fake <ISimulation>();
_clonedSimulation = A.Fake <ISimulation>();
A.CallTo(() => _simulationFactory.CreateWithCalculationMethodsFrom(_simulation, A <IEnumerable <CalculationMethodWithCompoundName> > ._)).Returns(_clonedSimulation);
A.CallTo(() => _cloneManager.Clone(_parameterIdentification)).ReturnsLazily(() =>
{
var pi = new ParameterIdentification();
pi.AddSimulation(_simulation);
var identificationParameter = new IdentificationParameter();
identificationParameter.AddLinkedParameter(new ParameterSelection(_simulation, A.Fake <QuantitySelection>()));
pi.AddIdentificationParameter(identificationParameter);
pi.AddOutputMapping(new OutputMapping
{
OutputSelection = new SimulationQuantitySelection(_simulation, A.Fake <QuantitySelection>())
});
pi.Configuration.RunMode = new CategorialParameterIdentificationRunMode();
return(pi);
});
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationParametersFeedbackView>();
_exportTask = A.Fake <IParameterIdentificationExportTask>();
sut = new ParameterIdentificationParametersFeedbackPresenter(_view, _exportTask);
_paramterIdentification = new ParameterIdentification();
_identificationParameter1 = createIdentificationParameter("P1", 10, 0, 20);
_identificationParameter2 = createIdentificationParameter("P2", 20, 5, 40);
_identificationParameter3 = createIdentificationParameter("P3", 20, 5, 40);
_identificationParameter3.IsFixed = true;
_paramterIdentification.AddIdentificationParameter(_identificationParameter1);
_paramterIdentification.AddIdentificationParameter(_identificationParameter2);
_paramterIdentification.AddIdentificationParameter(_identificationParameter3);
A.CallTo(() => _view.BindTo(A <IEnumerable <ParameterFeedbackDTO> > ._, A <IEnumerable <IRunPropertyDTO> > ._))
.Invokes(x =>
{
_allParameterFeedbackDTO = x.GetArgument <IEnumerable <ParameterFeedbackDTO> >(0).ToList();
_allPropertiesDTO = x.GetArgument <IEnumerable <IRunPropertyDTO> >(1).ToList();
});
sut.EditParameterIdentification(_paramterIdentification);
}
public void EditParameterIdentification(ParameterIdentification parameterIdentification)
{
_parameterIdentification = parameterIdentification;
_simulationParametersPresenter.EditParameterAnalysable(parameterIdentification);
_identificationParametersPresenter.EditParameterIdentification(parameterIdentification);
_linkedParametersPresenter.EditParameterIdentification(parameterIdentification);
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationChartFeedbackView>();
_chartDisplayPresenter = A.Fake <IChartDisplayPresenter>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_predictedVsObservedChartService = A.Fake <IPredictedVsObservedChartService>();
_displayUnitRetriever = A.Fake <IDisplayUnitRetriever>();
_parameterIdentification = A.Fake <ParameterIdentification>();
_observationColumns = new List <DataColumn>();
_curveList = new List <Curve>();
_baseGrid = DomainHelperForSpecs.ObservedData().BaseGrid;
_outputMapping = new OutputMapping();
sut = new ParameterIdentificationPredictedVsObservedFeedbackPresenter(_view, _chartDisplayPresenter, _dimensionFactory, _displayUnitRetriever, _predictedVsObservedChartService);
A.CallTo(() => _parameterIdentification.AllOutputMappings).Returns(new[] { _outputMapping });
A.CallTo(() => _parameterIdentification.AllObservationColumnsFor(A <string> ._)).Returns(_observationColumns);
_observationColumns.Add(new DataColumn());
_observationColumns.Add(new DataColumn());
A.CallTo(() => _predictedVsObservedChartService.AddCurvesFor(_observationColumns, A <DataColumn> ._, A <ParameterIdentificationPredictedVsObservedChart> ._, A <Action <DataColumn, Curve> > ._)).Invokes(x =>
{
var action = x.Arguments.Get <Action <DataColumn, Curve> >(3);
_observationColumns.Each(observation =>
{
var curve = new Curve {
Name = "Best"
};
action(new DataColumn(ShortGuid.NewGuid(), A.Fake <IDimension>(), _baseGrid), curve);
_curveList.Add(curve);
});
_chart = x.GetArgument <ParameterIdentificationPredictedVsObservedChart>(2);
});
}
protected override void Context()
{
_mapper = A.Fake <ICategorialParameterIdentificationToCalculationMethodPermutationMapper>();
_runInitializerFactory = A.Fake <IParameterIdentificationRunInitializerFactory>();
_parameterIdentification = new ParameterIdentification();
_parameterIdentification.Configuration.RunMode = new CategorialParameterIdentificationRunMode();
_aCombination = new List <CalculationMethodWithCompoundName>();
_anotherCombination = new List <CalculationMethodWithCompoundName>();
_calculationMethodCombinations = new List <CalculationMethodCombination> {
new CalculationMethodCombination(_aCombination), new CalculationMethodCombination(_anotherCombination)
};
_aCombination.Add(new CalculationMethodWithCompoundName(new CalculationMethod {
Category = "category1", DisplayName = "method1"
}, "compound1"));
_aCombination.Add(new CalculationMethodWithCompoundName(new CalculationMethod {
Category = "category2", DisplayName = "method2"
}, "compound1"));
_anotherCombination.Add(new CalculationMethodWithCompoundName(new CalculationMethod {
Category = "category1", DisplayName = "method3"
}, "compound1"));
_anotherCombination.Add(new CalculationMethodWithCompoundName(new CalculationMethod {
Category = "category2", DisplayName = "method4"
}, "compound1"));
sut = new CategorialParameterIdentificationRunFactory(_runInitializerFactory, _mapper);
A.CallTo(() => _mapper.MapFrom(A <ParameterIdentification> ._)).Returns(_calculationMethodCombinations);
}
public IReadOnlyList <IParameterIdentificationRun> CreateFor(ParameterIdentification parameterIdentification, CancellationToken cancellationToken)
{
var runInitializer = _runInitializerFactory.Create <StandardParameterIdentificationRunInitializer>();
runInitializer.Initialize(parameterIdentification, runIndex: 0);
return(new[] { runInitializer.Run });
}
protected override void Context()
{
_parameterTask = A.Fake <ISetParameterTask>();
_dialogCreator = A.Fake <IDialogCreator>();
_parameterIdentification = new ParameterIdentification();
_runResult = new ParameterIdentificationRunResult();
_runResult.BestResult.AddValue(new OptimizedParameterValue("P1", 10, 20));
_runResult.BestResult.AddValue(new OptimizedParameterValue("P2", 4, 5));
_identificationParameter1 = new IdentificationParameter {
Name = "P1"
};
_identificationParameter2 = new IdentificationParameter {
Name = "P2", UseAsFactor = true
};
_identificationParameter3 = new IdentificationParameter {
Name = "P3", IsFixed = true,
};
_identificationParameter3.Add(DomainHelperForSpecs.ConstantParameterWithValue(25).WithName(Constants.Parameters.START_VALUE));
_linkedParameter1 = A.Fake <ParameterSelection>();
A.CallTo(() => _linkedParameter1.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(2));
_linkedParameter2 = A.Fake <ParameterSelection>();
A.CallTo(() => _linkedParameter2.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(3));
A.CallTo(() => _linkedParameter2.Dimension).Returns(Constants.Dimension.NO_DIMENSION);
_linkedParameter3 = A.Fake <ParameterSelection>();
A.CallTo(() => _linkedParameter3.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(4));
A.CallTo(() => _linkedParameter3.Dimension).Returns(Constants.Dimension.NO_DIMENSION);
_linkedParameter4 = A.Fake <ParameterSelection>();
A.CallTo(() => _linkedParameter4.Parameter).Returns(DomainHelperForSpecs.ConstantParameterWithValue(5));
A.CallTo(() => _linkedParameter4.Dimension).Returns(Constants.Dimension.NO_DIMENSION);
_identificationParameter1.AddLinkedParameter(_linkedParameter1);
_identificationParameter2.AddLinkedParameter(_linkedParameter2);
_identificationParameter2.AddLinkedParameter(_linkedParameter3);
_identificationParameter3.AddLinkedParameter(_linkedParameter4);
_parameterIdentification.AddIdentificationParameter(_identificationParameter1);
_parameterIdentification.AddIdentificationParameter(_identificationParameter2);
_parameterIdentification.AddIdentificationParameter(_identificationParameter3);
_context = A.Fake <IOSPSuiteExecutionContext>();
sut = new TestTransferOptimizedParametersToSimulationsTask(_parameterTask, _dialogCreator, _context);
_allValueOriginCommands = new List <ICommand>();
A.CallTo(() => _parameterTask.SetParameterValue(A <IParameter> ._, A <double> ._, A <ISimulation> ._)).ReturnsLazily(x => A.Fake <IOSPSuiteCommmand <IOSPSuiteExecutionContext> >());
A.CallTo(() => _parameterTask.UpdateParameterValueOrigin(A <IParameter> ._, A <ValueOrigin> ._, A <ISimulation> ._)).ReturnsLazily(x =>
{
var command = A.Fake <IOSPSuiteCommmand <IOSPSuiteExecutionContext> >();
_allValueOriginCommands.Add(command);
return(command);
});
}
protected override void Context()
{
sut = new CategorialParameterIdentificationToCalculationMethodPermutationMapper();
_parameterIdentification = new ParameterIdentification();
_runMode = new CategorialParameterIdentificationRunMode();
_parameterIdentification.Configuration.RunMode = _runMode;
}
protected override void Context()
{
base.Context();
_relatedObject = A.Fake <ParameterIdentification>().WithId("XX");
_relatedItem.Origin = Origins.PKSim;
A.CallTo(() => _relatedItemSerializer.Deserialize(_relatedItem)).Returns(_relatedObject);
}
private Task export(ParameterIdentification parameterIdentification, string templatePath, string exportFileExtension)
{
var exportDirectory = getExportDirectory(parameterIdentification);
exportFor(parameterIdentification, exportDirectory, templatePath, exportFileExtension);
return(exportParameterIdentificationContent(parameterIdentification, exportDirectory));
}
protected override void Context()
{
base.Context();
_newOptions = A.Fake <MultipleParameterIdentificationRunMode>();
_parameterIdentification = new ParameterIdentification();
_parameterIdentification.Configuration.RunMode = _newOptions;
}
public void Initialize(ParameterIdentification parameterIdentification, int runIndex, CalculationMethodCombination calculationMethodCombination, bool isSingleCategory)
{
Initialize(parameterIdentification, runIndex);
_calculationMethodCombination = calculationMethodCombination;
_isSingleCategory = isSingleCategory;
_runMode = parameterIdentification.Configuration.RunMode.DowncastTo <CategorialParameterIdentificationRunMode>();
}