public void CreateMarkovChainWithHazardsRetraversal2()
{
var model = new DeadReckoningModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
var retraversalMarkovChainGenerator = new MarkovChainFromMarkovChainGenerator(markovChain);
retraversalMarkovChainGenerator.Configuration.SuccessorCapacity *= 2;
retraversalMarkovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
retraversalMarkovChainGenerator.Configuration.UseCompactStateStorage = true;
retraversalMarkovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
retraversalMarkovChainGenerator.GenerateLabeledMarkovChain();
}
public void CalculateMdpFlattened()
{
var model = new DeadReckoningModel();
model.Component.FF.ProbabilityOfOccurrence = null;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuildInMdpWithNewStates;
markovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var nmdp = markovChainGenerator.GenerateNestedMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdpByFlattening(nmdp);
}
public void CalculateHazardWithoutEarlyTermination()
{
var model = new DeadReckoningModel();
SafetySharpModelChecker.TraversalConfiguration.EnableEarlyTermination = false;
var result = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.Hazard, 10);
SafetySharpModelChecker.TraversalConfiguration.EnableEarlyTermination = true;
Console.Write($"Probability of hazard: {result}");
}
public void CalculateRangeHazardLtmdp()
{
var model = new DeadReckoningModel();
model.Component.FF.ProbabilityOfOccurrence = null;
SafetySharpModelChecker.TraversalConfiguration.EnableStaticPruningOptimization = true;
SafetySharpModelChecker.TraversalConfiguration.LtmdpModelChecker = LtmdpModelChecker.BuildInMdpWithNewStates;
var result = SafetySharpModelChecker.CalculateProbabilityRangeToReachStateBounded(model, model.Component.Hazard, 10);
Console.Write($"Probability of hazard: {result}");
}
public void TestScoreBasedLearning()
{
var model = new DeadReckoningModel();
Func <bool> hazard = () => model.Component.Hazard;
Func <bool> state = () => model.Component.NoDataAvailable || model.Component.CalculationError;
var states = new Dictionary <string, Func <bool> > { /*["State"] = state*/
};
var config = BayesianLearningConfiguration.Default;
var bayesianCreator = new BayesianNetworkCreator(model, 10, config);
var result = bayesianCreator.LearnScoreBasedBayesianNetwork(@"C:\SafetySharpSimulation\", 100000, hazard, states);
}
public void CalculateHazardProbability()
{
var tc = SafetySharpModelChecker.TraversalConfiguration;
tc.WriteGraphvizModels = true;
tc.EnableStaticPruningOptimization = false;
SafetySharpModelChecker.TraversalConfiguration = tc;
var model = new DeadReckoningModel();
var result = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.Hazard, 10);
Console.WriteLine($"Probability of hazard in model: {result}");
}
public void CalculateBayesianNetworkProbabilities()
{
const string filePath = "network.json";
var model = new DeadReckoningModel();
Func <bool> hazard = () => model.Component.Hazard;
var bayesianNetworkCreator = new BayesianNetworkCreator(model, 10);
var network = bayesianNetworkCreator.FromJson(filePath, hazard);
var calculator = new BayesianNetworkProbabilityDistributionCalculator(network, 0.0000000001);
var result = calculator.CalculateConditionalProbabilityDistribution(new[] { "FS" }, new[] { "FC", "FF" });
Console.Out.WriteLine(string.Join("\n", result));
}
public void TestConstraintBasedLearning()
{
var model = new DeadReckoningModel();
Func <bool> hazard = () => model.Component.Hazard;
Func <bool> state = () => true;
var states = new Dictionary <string, Func <bool> > { /*["State"] = state*/
};
var config = BayesianLearningConfiguration.Default;
var bayesianNetworkCreator = new BayesianNetworkCreator(model, 10, config);
var result = bayesianNetworkCreator.LearnConstraintBasedBayesianNetwork(hazard, states, new[] { model.Component.FF, model.Component.FS, model.Component.FC });
}
public void CalculateHazardSingleCore()
{
var model = new DeadReckoningModel();
SafetySharpModelChecker.TraversalConfiguration.CpuCount = 1;
SafetySharpModelChecker.TraversalConfiguration.EnableEarlyTermination = false;
SafetySharpModelChecker.TraversalConfiguration.EnableStaticPruningOptimization = false;
var result = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.Hazard, 10);
SafetySharpModelChecker.TraversalConfiguration.CpuCount = Int32.MaxValue;
SafetySharpModelChecker.TraversalConfiguration.EnableEarlyTermination = true;
SafetySharpModelChecker.TraversalConfiguration.EnableStaticPruningOptimization = true;
Console.Write($"Probability of hazard: {result}");
}
public void SerializeAndDeserializeBayesianNetwork()
{
const string filePath = "network.json";
var model = new DeadReckoningModel();
Func <bool> hazard = () => model.Component.Hazard;
var config = BayesianLearningConfiguration.Default;
config.BayesianNetworkSerializationPath = filePath;
var bayesianNetworkCreator = new BayesianNetworkCreator(model, 10, config);
var result = bayesianNetworkCreator.LearnConstraintBasedBayesianNetwork(hazard, null, new[] { model.Component.FF, model.Component.FS, model.Component.FC });
bayesianNetworkCreator = new BayesianNetworkCreator(model, 10);
var network = bayesianNetworkCreator.FromJson(filePath, hazard);
}
public void CalculateDcca()
{
var model = new DeadReckoningModel();
var analysis = new SafetySharpSafetyAnalysis
{
Backend = SafetyAnalysisBackend.FaultOptimizedOnTheFly,
Heuristics = { new MaximalSafeSetHeuristic(model.Faults) }
};
var result = analysis.ComputeMinimalCriticalSets(model, model.Component.Hazard);
var orderResult = SafetySharpOrderAnalysis.ComputeOrderRelationships(result);
Console.WriteLine(orderResult);
}
public void CreateMarkovChainWithHazards()
{
var model = new DeadReckoningModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateMarkovChain();
}
public void CreateMarkovChainWithFalseFormula()
{
var model = new DeadReckoningModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(new ExecutableStateFormula(() => false));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateMarkovChain();
}
public void CalculateFaultProbabilities()
{
var tc = SafetySharpModelChecker.TraversalConfiguration;
tc.WriteGraphvizModels = true;
tc.EnableStaticPruningOptimization = false;
SafetySharpModelChecker.TraversalConfiguration = tc;
var model = new DeadReckoningModel();
var isFlActivated = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.FF.IsActivated, 20);
var isFvActivated = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.FC.IsActivated, 20);
var isFsActivated = SafetySharpModelChecker.CalculateProbabilityToReachStateBounded(model, model.Component.FS.IsActivated, 20);
Console.WriteLine($"Probability that Fault1 is activated: {isFlActivated}");
Console.WriteLine($"Probability that Fault2 is activated: {isFvActivated}");
Console.WriteLine($"Probability that Fault2 is activated: {isFsActivated}");
}
public void CalculateLtmdpWithoutFaultsWithPruning()
{
var model = new DeadReckoningModel();
model.Component.FF.ProbabilityOfOccurrence = null;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = true;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
markovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var model = new DeadReckoningModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
var formula = new ExecutableStateFormula(() => model.Component.Hazard);
var onceFormula = new UnaryFormula(formula, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(model.Component.FC), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
foreach (var fault in model.Faults.Where(fault => fault != model.Component.FC))
{
var faultFormula = new UnaryFormula(new FaultFormula(fault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
var formulaToCheck = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFormula), UnaryOperator.Finally, 10);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
markovChainGenerator.Configuration.CpuCount = Int32.MaxValue;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
Console.Write($"Probability of hazard: {result}");
}
}
public void ManuallyCalculateProbabilities()
{
var model = new DeadReckoningModel();
Func <bool> hazard = () => model.Component.Hazard;
var config = BayesianLearningConfiguration.Default;
var tolerance = 0.000000001;
var stepBounds = 10; //230 for railroad crossing
var allVars = new List <RandomVariable>();
var randomVariableFactory = new RandomVariableFactory(model);
var rvFaultF = randomVariableFactory.FromFault(model.Component.FF);
var rvFaultC = randomVariableFactory.FromFault(model.Component.FC);
var rvFaultS = randomVariableFactory.FromFault(model.Component.FS);
var mcs = new MinimalCriticalSet(new HashSet <Fault>()
{
model.Component.FC, model.Component.FS
});
var rvMcs = new McsRandomVariable(mcs, new[] { rvFaultC, rvFaultS }, "mcs_FC_FS");
var rvHazard = randomVariableFactory.FromState(hazard, "H");
allVars.AddRange(new RandomVariable[] { rvFaultF, rvFaultC, rvFaultS, rvMcs, rvHazard });
var probCalculator = new OnDemandProbabilityDistributionCalculator(model, allVars, stepBounds, tolerance, config);
var result = probCalculator.CalculateProbability(new RandomVariable[] { rvHazard }, new RandomVariable[] { });
Console.Out.WriteLine($"Probability of {rvHazard}+: {result}");
Console.Out.WriteLine();
GC.Collect();
result = probCalculator.CalculateProbability(new RandomVariable[] { rvHazard }, new RandomVariable[] { rvFaultF });
Console.Out.WriteLine($"Probability of {rvHazard}+,{rvFaultF}- : {result}");
Console.Out.WriteLine();
GC.Collect();
probCalculator.WriteProbsToConsole();
}
public void CreateFaultAwareMarkovChainAllFaults()
{
var model = new DeadReckoningModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.AddFormulaToCheck(model.Component.Hazard);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateMarkovChain();
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
var model = new DeadReckoningModel();
model.Component.FF.ProbabilityOfOccurrence = null;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
var formula = new ExecutableStateFormula(() => model.Component.Hazard);
var formulaToCheck = new BoundedUnaryFormula(formula, UnaryOperator.Finally, 10);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
markovChainGenerator.Configuration.CpuCount = 1;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(formulaToCheck);
Console.Write($"Probability of hazard: {result}");
}
}
