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