public Action_MakeAxe()
{
Init();
actionID = "MakeAxe";
VariationData ironAxe = new VariationData();
ironAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.Iron);
ironAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.Wood);
ironAxe.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.IronAxe);
ironAxe.benefitingSkill = Skills.Smithing;
ironAxe.workCost = 1f;
ironAxe.range = 1f;
variations.Add(ironAxe);
VariationData stoneAxe = new VariationData();
stoneAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.Stone);
stoneAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.Wood);
stoneAxe.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.StoneAxe);
stoneAxe.workCost = 4f;
stoneAxe.range = 1f;
variations.Add(stoneAxe);
}
protected override void Context()
{
base.Context();
_runOptions = new SensitivityAnalysisRunOptions();
_allEvents = new List <SensitivityAnalysisEvent>();
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisStartedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisStartedEvent>(0)));
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisTerminatedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisTerminatedEvent>(0)));
A.CallTo(() => _eventPublisher.PublishEvent(A <SensitivityAnalysisResultsUpdatedEvent> ._))
.Invokes(x => _allEvents.Add(x.GetArgument <SensitivityAnalysisResultsUpdatedEvent>(0)));
_variationData = A.Fake <VariationData>();
_dataTable = new DataTable();
A.CallTo(() => _variationData.ToDataTable()).Returns(_dataTable);
A.CallTo(() => _sensitivityAnalysisVariationDataCreator.CreateForRun(_sensitivityAnalysis)).Returns(_variationData);
_populationRunResult = new PopulationRunResults {
Results = new SimulationResults()
};
A.CallTo(() => _populationRunner.RunPopulationAsync(_modelCoreSimulation, _runOptions, _dataTable, null, null)).ReturnsAsync(_populationRunResult);
_sensitivityAnalysisResults = new SensitivityAnalysisRunResult();
A.CallTo(() => _runResultCalculator.CreateFor(_sensitivityAnalysis, _variationData, _populationRunResult.Results, false)).Returns(_sensitivityAnalysisResults);
}
public Action_ChopTree()
{
Init();
actionID = "ChopTree";
VariationData ironAxe = new VariationData();
ironAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.IronAxe);
ironAxe.AddRequiredWorldState(WorldStateKey.bIsTreeAvailable, 1);
ironAxe.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.Log);
ironAxe.benefitingSkill = Skills.WoodCutting;
ironAxe.workCost = 4f;
ironAxe.range = 1f;
variations.Add(ironAxe);
VariationData stoneAxe = new VariationData();
stoneAxe.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.StoneAxe);
stoneAxe.AddRequiredWorldState(WorldStateKey.bIsTreeAvailable, 1);
stoneAxe.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.Log);
stoneAxe.benefitingSkill = Skills.WoodCutting;
stoneAxe.workCost = 12f;
stoneAxe.range = 1f;
variations.Add(stoneAxe);
}
protected override void Context()
{
_pkAnalysisTask = A.Fake <ISensitivityAnalysisPKAnalysesTask>();
sut = new SensitivityAnalysisRunResultCalculator(_pkAnalysisTask);
_pkAnalyses = new PopulationSimulationPKAnalyses();
_sensitivityAnalysis = new SensitivityAnalysis();
_variationData = new VariationData();
_simulationResults = new SimulationResults();
A.CallTo(_pkAnalysisTask).WithReturnType <PopulationSimulationPKAnalyses>().Returns(_pkAnalyses);
}
public VariationData CreateForRun(SensitivityAnalysis sensitivityAnalysis)
{
var variationData = new VariationData
{
Name = sensitivityAnalysis.Name,
ParameterPaths = sensitivityAnalysis.AllSensitivityParameters.Select(x => x.ParameterSelection.Path).ToList(),
DefaultValues = sensitivityAnalysis.AllSensitivityParameters.Select(x => x.Parameter.Value).ToList(),
};
sensitivityAnalysis.AllSensitivityParameters.Each(parameter =>
{
variationData.AddVariationValues(parameter.Name, sensitivityAnalysis.AllParameterVariationsFor(parameter).ToList());
});
return(variationData);
}
private void addPKAnalysisSensitivities(VariationData variationData, SimulationResults simulationResults, SensitivityAnalysisRunResult sensitivityRunResult, SensitivityAnalysis sensitivityAnalysis)
{
var pkAnalyses = _pkAnalysesTask.CalculateFor(sensitivityAnalysis.Simulation, simulationResults);
foreach (var pkParameter in pkAnalyses.All())
{
sensitivityAnalysis.AllSensitivityParameters.Each(sensitivityParameter =>
{
var pkSensitivity = calculatePKParameterSensitivity(sensitivityParameter, variationData, pkParameter);
if (pkSensitivity != null)
{
sensitivityRunResult.AddPKParameterSensitivity(pkSensitivity);
}
});
}
}
private void addOutputSensitivities(VariationData variationData, SimulationResults simulationResults, SensitivityAnalysisRunResult sensitivityRunResult, SensitivityAnalysis sensitivityAnalysis)
{
variationData.AllVariations.Each(variation =>
{
//one variation corresponds to one row in the simulation table (e.g. one IndividualId)
//this is the variation of one parameter compared to the base simulation
var resultsForVariation = simulationResults.ResultsFor(variation.VariationId);
//Retrieve this parameter
var sensitivityParameter = sensitivityAnalysis.SensitivityParameterByName(variation.ParameterName);
var parameterPath = sensitivityParameter.ParameterSelection.Path;
//For all output, we add the sensitivity
resultsForVariation.AllValues.Each(outputValue =>
{
var outputParameterSensitivity = calculateOutputParameterSensitivity(outputValue, variation, parameterPath);
sensitivityRunResult.AddOutputParameterSensitivity(outputParameterSensitivity);
});
});
}
public Action_MineIron()
{
Init();
actionID = "MineIron";
VariationData ironPick = new VariationData();
ironPick.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.IronPickaxe);
ironPick.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.Iron);
ironPick.workCost = 5f;
ironPick.range = 1f;
variations.Add(ironPick);
VariationData stonePick = new VariationData();
stonePick.AddRequiredWorldState(WorldStateKey.eHasItem, (int)ItemType.StoneAxe);
stonePick.AddSatisfyWorldState(WorldStateKey.eHasItem, (int)ItemType.Iron);
stonePick.workCost = 15f;
stonePick.range = 1f;
variations.Add(stonePick);
}
private PKParameterSensitivity calculateParameterSensitivity(SensitivityParameter sensitivityParameter, int sensitivityParameterIndex, VariationData variationData, QuantityPKParameter pkParameter)
{
var defaultParameterValue = sensitivityParameter.DefaultValue;
var defaultPKValue = pkParameter.Values[variationData.DefaultVariationId];
var allVariations = variationData.VariationsFor(sensitivityParameter.Name);
if (float.IsNaN(defaultPKValue) || defaultPKValue == 0 || defaultParameterValue == 0 || !allVariations.Any())
{
return(null);
}
var sensitivity = new PKParameterSensitivity
{
ParameterName = sensitivityParameter.Name,
PKParameterName = pkParameter.Name,
QuantityPath = pkParameter.QuantityPath,
Value = double.NaN
};
var delta = (from variation in allVariations
let deltaP = difference(variation.Variation[sensitivityParameterIndex], defaultParameterValue)
let deltaPK = difference(pkParameter.Values[variation.VariationId], defaultPKValue)
select deltaPK / deltaP).Sum();
sensitivity.Value = delta * defaultParameterValue / defaultPKValue / allVariations.Count;
if (Math.Abs(sensitivity.Value) < Constants.SENSITIVITY_THRESHOLD)
{
sensitivity.Value = 0.0;
}
return(sensitivity);
}
public SensitivityAnalysisRunResult CreateFor(SensitivityAnalysis sensitivityAnalysis, VariationData variationData, SimulationResults simulationResults)
{
var sensitivityRunResult = new SensitivityAnalysisRunResult();
var pkAnalyses = _pkAnalysesTask.CalculateFor(sensitivityAnalysis.Simulation, variationData.NumberOfVariations, simulationResults);
foreach (var pkParameter in pkAnalyses.All())
{
sensitivityAnalysis.AllSensitivityParameters.Each((sensitivityParameter, index) =>
{
var pkSensitivity = calculateParameterSensitivity(sensitivityParameter, index, variationData, pkParameter);
if (pkSensitivity != null)
{
sensitivityRunResult.AddPKParameterSensitivity(pkSensitivity);
}
});
}
return(sensitivityRunResult);
}
private Task <SensitivityAnalysisRunResult> calculateSensitivityBasedOn(SensitivityAnalysis sensitivityAnalysis, VariationData variationData, PopulationRunResults runResults)
{
return(Task.Run(() => _runResultCalculator.CreateFor(sensitivityAnalysis, variationData, runResults.Results)));
}
public SensitivityAnalysisRunResult CreateFor(SensitivityAnalysis sensitivityAnalysis, VariationData variationData, SimulationResults simulationResults, bool addOutputParameterSensitivitiesToResult)
{
var sensitivityRunResult = new SensitivityAnalysisRunResult();
addPKAnalysisSensitivities(variationData, simulationResults, sensitivityRunResult, sensitivityAnalysis);
if (addOutputParameterSensitivitiesToResult)
{
addOutputSensitivities(variationData, simulationResults, sensitivityRunResult, sensitivityAnalysis);
}
return(sensitivityRunResult);
}
