private SimulationResults createResultsFrom(DataRepository dataRepository, ISimModelBatch simModel, string[] parameters)
{
if (dataRepository.IsNull() || dataRepository.BaseGrid == null)
{
return(new NullSimulationResults());
}
var results = new SimulationResults {
Time = valuesFrom(dataRepository.BaseGrid, null, new string[] { })
};
foreach (var columnsForIndividual in dataRepository.AllButBaseGrid().GroupBy(selectIndividualIndex))
{
var individualResults = new IndividualResults {
IndividualId = columnsForIndividual.Key, Time = results.Time
};
foreach (var dataColumn in columnsForIndividual)
{
individualResults.Add(valuesFrom(dataColumn, pathWithoutIndividualIndex(dataColumn, columnsForIndividual.Key), simModel, parameters));
}
individualResults.UpdateQuantityTimeReference();
results.Add(individualResults);
}
return(results);
}
public SimulationBatch(ISimModelBatch simModelBatch,
ISimulationResultsCreator simulationResultsCreator,
ISimulationPersistableUpdater simulationPersistableUpdater
)
{
_simModelBatch = simModelBatch;
_simulationResultsCreator = simulationResultsCreator;
_simulationPersistableUpdater = simulationPersistableUpdater;
}
protected override void Context()
{
_modelCoreSimulationMapper = A.Fake <ISimulationToModelCoreSimulationMapper>();
_residualCalculatorFactory = A.Fake <IResidualCalculatorFactory>();
_timeGridUpdater = A.Fake <ITimeGridUpdater>();
_simModelBatchFactory = A.Fake <ISimModelBatchFactory>();
_optimizationAlgorithmMapper = A.Fake <IParameterIdentificationAlgorithmToOptmizationAlgorithmMapper>();
_outputSelectionUpdater = A.Fake <IOutputSelectionUpdater>();
_coreUserSettings = A.Fake <ICoreUserSettings>();
_jacobianMatrixCalculator = A.Fake <IJacobianMatrixCalculator>();
_coreUserSettings.MaximumNumberOfCoresToUse = 2;
sut = new ParameterIdentificationRun(_residualCalculatorFactory, _timeGridUpdater, _simModelBatchFactory, _modelCoreSimulationMapper,
_optimizationAlgorithmMapper, _outputSelectionUpdater, _coreUserSettings, _jacobianMatrixCalculator);
_simulation = A.Fake <ISimulation>();
_parameter1 = A.Fake <IParameter>();
_parameter1.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_parameter1.Value = 15;
_parameter2 = A.Fake <IParameter>();
_parameter2.Value = 35;
_parameter2.Dimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
_parameterIdentification = new ParameterIdentification();
_parameterIdentification.Configuration.LLOQMode = LLOQModes.OnlyObservedData;
_parameterIdentification.Configuration.RemoveLLOQMode = RemoveLLOQModes.NoTrailing;
_parameterIdentification.AddSimulation(_simulation);
_parameterSelection1 = ParameterSelectionFor(_parameter1, "ParameterPath1");
_parameterSelection2 = ParameterSelectionFor(_parameter2, "ParameterPath2");
_identificationParameter = DomainHelperForSpecs.IdentificationParameter("IdParam", min: 10, max: 20, startValue: 15);
_identificationParameter.AddLinkedParameter(_parameterSelection1);
_identificationParameter.AddLinkedParameter(_parameterSelection2);
_modelCoreSimulation = A.Fake <IModelCoreSimulation>();
A.CallTo(() => _modelCoreSimulationMapper.MapFrom(_simulation, true)).Returns(_modelCoreSimulation);
_outputMapping = A.Fake <OutputMapping>();
A.CallTo(() => _outputMapping.UsesSimulation(_simulation)).Returns(true);
A.CallTo(() => _outputMapping.WeightedObservedData.ObservedData).Returns(DomainHelperForSpecs.ObservedData());
_parameterIdentification.AddOutputMapping(_outputMapping);
_simModelBatch = A.Fake <ISimModelBatch>();
A.CallTo(() => _simModelBatchFactory.Create()).Returns(_simModelBatch);
_parameterIdentification.AddIdentificationParameter(_identificationParameter);
_residualCalculator = A.Fake <IResidualCalculator>();
A.CallTo(_residualCalculatorFactory).WithReturnType <IResidualCalculator>().Returns(_residualCalculator);
_algorithm = A.Fake <IOptimizationAlgorithm>();
A.CallTo(() => _optimizationAlgorithmMapper.MapFrom(_parameterIdentification.AlgorithmProperties)).Returns(_algorithm);
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
_runInitializer = A.Fake <IParameterIdentifcationRunInitializer>();
A.CallTo(() => _runInitializer.InitializeRun()).ReturnsAsync(_parameterIdentification);
PerformExtraInitializationSteps();
sut.InitializeWith(_runInitializer);
}
//context shoud represent use case defined in 47-7990 Management of Jacobi Matrix
protected override void Context()
{
_parameterIdentification = A.Fake <ParameterIdentification>();
_runResult = A.Fake <OptimizationRunResult>();
_simModelBatches = new Dictionary <ISimulation, ISimModelBatch>();
_allOutputMappings = new List <OutputMapping>();
_allVariableIdentificationParameters = new List <IdentificationParameter>();
A.CallTo(() => _parameterIdentification.AllOutputMappings).Returns(_allOutputMappings);
A.CallTo(() => _parameterIdentification.AllVariableIdentificationParameters).Returns(_allVariableIdentificationParameters);
sut = new JacobianMatrixCalculator();
_output1 = A.Fake <OutputMapping>();
_simulation1 = A.Fake <ISimulation>();
_simModelBatch1 = A.Fake <ISimModelBatch>();
_simModelBatches.Add(_simulation1, _simModelBatch1);
A.CallTo(() => _output1.Simulation).Returns(_simulation1);
A.CallTo(() => _output1.FullOutputPath).Returns("S1|OutputPath1");
A.CallTo(() => _output1.OutputPath).Returns("OutputPath1");
_allOutputMappings.Add(_output1);
_output2 = A.Fake <OutputMapping>();
_simulation2 = A.Fake <ISimulation>();
_simModelBatch2 = A.Fake <ISimModelBatch>();
A.CallTo(() => _output2.Simulation).Returns(_simulation2);
A.CallTo(() => _output2.FullOutputPath).Returns("S2|OutputPath2");
A.CallTo(() => _output2.OutputPath).Returns("OutputPath2");
_simModelBatches.Add(_simulation2, _simModelBatch2);
_allOutputMappings.Add(_output2);
_identificationParameter1 = new IdentificationParameter().WithName("IP1");
_identificationParameter2 = new IdentificationParameter().WithName("IP2");
_ps1 = A.Fake <ParameterSelection>();
_ps1.Parameter.Value = 100;
A.CallTo(() => _ps1.FullQuantityPath).Returns("S1|ParameterPath1");
A.CallTo(() => _ps1.Path).Returns("ParameterPath1");
A.CallTo(() => _ps1.Simulation).Returns(_simulation1);
_identificationParameter1.AddLinkedParameter(_ps1);
_ps2 = A.Fake <ParameterSelection>();
_ps2.Parameter.Value = 200;
A.CallTo(() => _ps2.FullQuantityPath).Returns("S2|ParameterPath2");
A.CallTo(() => _ps2.Path).Returns("ParameterPath2");
A.CallTo(() => _ps2.Simulation).Returns(_simulation2);
A.CallTo(() => _ps2.Dimension).Returns(_ps1.Dimension);
_identificationParameter1.AddLinkedParameter(_ps2);
_ps3 = A.Fake <ParameterSelection>();
_ps3.Parameter.Value = 300;
A.CallTo(() => _ps3.FullQuantityPath).Returns("S2|ParameterPath3");
A.CallTo(() => _ps3.Path).Returns("ParameterPath3");
A.CallTo(() => _ps3.Simulation).Returns(_simulation2);
_identificationParameter2.AddLinkedParameter(_ps3);
_allVariableIdentificationParameters.Add(_identificationParameter1);
_allVariableIdentificationParameters.Add(_identificationParameter2);
A.CallTo(() => _runResult.AllResidualsFor(_output1.FullOutputPath)).Returns(new[] { new Residual(1, 11, 1), new Residual(2, 21, 2), new Residual(3, 31, 0) });
A.CallTo(() => _runResult.AllResidualsFor(_output2.FullOutputPath)).Returns(new[] { new Residual(1, 12, 3), new Residual(3, 32, 4), new Residual(4, 42, 5) });
A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps1.Path)).Returns(new[] { 11d, 21d, 31d, 41d, 51d });
A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps2.Path)).Throws(new OSPSuiteException());
A.CallTo(() => _simModelBatch1.SensitivityValuesFor(_output1.OutputPath, _ps3.Path)).Throws(new OSPSuiteException());
A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps1.Path)).Throws(new OSPSuiteException());
A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps2.Path)).Returns(new[] { 12d, 22d, 32d, 42d, 52d, 62d });
A.CallTo(() => _simModelBatch2.SensitivityValuesFor(_output2.OutputPath, _ps3.Path)).Returns(new[] { 13d, 23d, 33d, 43d, 53d, 63d });
_simResults1 = new DataColumn
{
BaseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs())
{
Values = new[] { 1f, 2f, 3f, 4f, 5f }
},
Values = new[] { 10f, 20f, 30f, 40f, 50f }
};
A.CallTo(() => _runResult.SimulationResultFor(_output1.FullOutputPath)).Returns(_simResults1);
_simResults2 = new DataColumn
{
BaseGrid = new BaseGrid("Time", DomainHelperForSpecs.TimeDimensionForSpecs())
{
Values = new[] { 1f, 2f, 3f, 4f, 5f, 6f }
},
Values = new[] { 10f, 20f, 30f, 40f, 50f, 60f }
};
A.CallTo(() => _runResult.SimulationResultFor(_output2.FullOutputPath)).Returns(_simResults2);
}
private QuantityValues valuesFrom(DataColumn dataColumn, string quantityPath, ISimModelBatch simModel, string[] parameters)
{
return(new QuantityValues
{
ColumnId = dataColumn.Id,
QuantityPath = quantityPath,
Values = dataColumn.Values.ToArray(),
Sensitivities = parameters.ToDictionary(p => p, p => simModel?.SensitivityValuesFor(quantityPath, p))
});
}
private QuantityValues valuesFrom(DataColumn dataColumn, ISimModelBatch simModel, string[] parameters)
{
return(valuesFrom(dataColumn, dataColumn.QuantityInfo.PathAsString, simModel, parameters));
}
public SimulationResults CreateResultsWithSensitivitiesFrom(DataRepository dataRepository, ISimModelBatch simModelBatch, string[] parameters)
{
return(createResultsFrom(dataRepository, simModelBatch, parameters));
}
private static double retrievePartialDerivativeForResiduals(ParameterSelection linkedParameter, OutputMapping outputMapping, ISimModelBatch simModelBatch, int timeIndex, float outputValue, double weight)
{
var partialDerivative = retrievePartialDerivativeForOutputs(linkedParameter, outputMapping, simModelBatch, timeIndex);
var sensitivityValue = partialDerivative * weight;
if (sensitivityValue == 0 || outputMapping.Scaling == Scalings.Linear)
{
return(sensitivityValue);
}
return(sensitivityValue / (outputValue * Math.Log(10)));
}
private static double retrievePartialDerivativeForOutputs(ParameterSelection linkedParameter, OutputMapping outputMapping, ISimModelBatch simModelBatch, int timeIndex)
{
if (!Equals(linkedParameter.Simulation, outputMapping.Simulation))
{
return(0);
}
var sensitivity = simModelBatch.SensitivityValuesFor(outputMapping.OutputPath, linkedParameter.Path);
return(sensitivity[timeIndex]);
}
private static IEnumerable <JacobianRow> jacobianRowFrom(OptimizationRunResult runResult, string fullOutputPath, DataColumn outputResult, IReadOnlyList <IdentificationParameter> allIdentificationParameters, OutputMapping outputMapping, ISimModelBatch simModelBatch)
{
var timeGrid = outputResult.BaseGrid;
return(from residual in runResult.AllResidualsFor(fullOutputPath).Where(x => x.Weight > 0)
let timeIndex = timeGrid.LeftIndexOf(Convert.ToSingle(residual.Time))
let outputValue = outputResult[timeIndex]
let derivativeValues = retrievePartialDerivativeFor(allIdentificationParameters, x => retrievePartialDerivativeForResiduals(x, outputMapping, simModelBatch, timeIndex, outputValue, residual.Weight))
select new JacobianRow(fullOutputPath, residual.Time, derivativeValues));
}
private PartialDerivatives partialDerivativesFrom(string fullOutputPath, DataColumn outputResult, IReadOnlyList <IdentificationParameter> allIdentificationParameters, OutputMapping outputMapping, ISimModelBatch simModelBatch)
{
var partialDerivatives = new PartialDerivatives(fullOutputPath, allIdentificationParameters.AllNames());
outputResult.Values.Each((outputValue, index) =>
{
var derivativeValues = retrievePartialDerivativeFor(allIdentificationParameters, x => retrievePartialDerivativeForOutputs(x, outputMapping, simModelBatch, index));
partialDerivatives.AddPartialDerivative(derivativeValues);
});
return(partialDerivatives);
}
