public void Check()
{
var m = new Model();
Probability probabilityOfFinal100;
Probability probabilityOfFinal200;
var final100Formula = new BoundedUnaryFormula(Model.StateIs100, UnaryOperator.Finally, 5);
var final200Formula = new BoundedUnaryFormula(Model.StateIs200, UnaryOperator.Finally, 5);
var nmdpGenerator = new SimpleNmdpFromExecutableModelGenerator(m);
nmdpGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
nmdpGenerator.AddFormulaToCheck(final100Formula);
nmdpGenerator.AddFormulaToCheck(final200Formula);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess();
nmdp.ExportToGv(Output.TextWriterAdapter());
var typeOfModelChecker = typeof(BuiltinNmdpModelChecker);
var modelChecker = (BuiltinNmdpModelChecker)Activator.CreateInstance(typeOfModelChecker, nmdp, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal100 = modelChecker.CalculateMinimalProbability(final100Formula);
probabilityOfFinal200 = modelChecker.CalculateMinimalProbability(final200Formula);
}
probabilityOfFinal100.Is(0.6 * 0.8, 0.000001).ShouldBe(true);
probabilityOfFinal200.Is(0.4 + 0.6 * 0.2, 0.000001).ShouldBe(true);
}
public void CheckWithFaultActivationInFormula()
{
var m = new Model();
Probability probabilityOfFinal1;
var state1WithFault1 = new BinaryFormula(new SimpleStateInRangeFormula(1), BinaryOperator.And, new FaultFormula(m.F1));
var finallyState1WithFault1 = new BoundedUnaryFormula(state1WithFault1, UnaryOperator.Finally, 1);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.WriteGraphvizModels = true;
markovChainGenerator.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
markovChainGenerator.AddFormulaToCheck(finallyState1WithFault1);
var dtmc = markovChainGenerator.GenerateMarkovChain();
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(finallyState1WithFault1);
}
probabilityOfFinal1.Is(0.275, 0.000001).ShouldBe(true);
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
var oldProbability = _faults[1].ProbabilityOfOccurrence;
_faults[1].ProbabilityOfOccurrence = null;
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <LustreExecutableModel>(_createModel);
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(10000, 1000000);
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
markovChainGenerator.AddFormulaToCheck(_hazard);
var formulaToCheck = new BoundedUnaryFormula(_hazard, UnaryOperator.Finally, 25);
foreach (var fault in _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();
_faults[1].ProbabilityOfOccurrence = oldProbability;
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(formulaToCheck);
Console.Write($"Probability of formulaToCheck: {result}");
}
}
private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfFinally2;
Probability probabilityOfFinally2b;
var finally2 = new UnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally);
var finally2b = new BoundedUnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally, 2);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(finally2);
markovChainGenerator.AddFormulaToCheck(finally2b);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinally2 = modelChecker.CalculateProbability(finally2);
probabilityOfFinally2b = modelChecker.CalculateProbability(finally2b);
}
probabilityOfFinally2.Between(0.33, 0.34).ShouldBe(true);
probabilityOfFinally2b.Between(0.33, 0.34).ShouldBe(true);
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var model = new DegradedModeModel();
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.System.HazardActive);
var onceFormula = new UnaryFormula(formula, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(model.System.SignalDetector1.F1), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
var formulaToCheck = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFormula), UnaryOperator.Finally, 50);
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}");
}
}
private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfFinal100;
Probability probabilityOfFinal200;
var final100Formula = new BoundedUnaryFormula(Model.StateIs100, UnaryOperator.Finally, 5);
var final200Formula = new BoundedUnaryFormula(Model.StateIs200, UnaryOperator.Finally, 5);
var mdpGenerator = new SimpleMarkovDecisionProcessFromExecutableModelGenerator(m);
mdpGenerator.Configuration = configuration;
mdpGenerator.AddFormulaToCheck(final100Formula);
mdpGenerator.AddFormulaToCheck(final200Formula);
var mdp = mdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var modelChecker = new ConfigurationDependentLtmdpModelChecker(configuration, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal100 = modelChecker.CalculateMinimalProbability(final100Formula);
probabilityOfFinal200 = modelChecker.CalculateMinimalProbability(final200Formula);
}
probabilityOfFinal100.Is(0.6 * 0.8, 0.000001).ShouldBe(true);
probabilityOfFinal200.Is(0.4 + 0.6 * 0.2, 0.000001).ShouldBe(true);
}
public void CalculateHazardSingleCoreAllFaults()
{
var model = new Model();
SetProbabilities(model);
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.CpuCount = 1;
var formulaToCheck = new BoundedUnaryFormula(model.PossibleCollision, UnaryOperator.Finally, 50);
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;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
Console.Write($"Probability of formulaToCheck: {result}");
}
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <LustreExecutableModel>(_createModel)
{
Configuration = LustreModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
var onceFormula = new UnaryFormula(_hazard, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(_faults[1]), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
foreach (var fault in _faults.Where(fault => fault != _faults[1]))
{
var faultFormula = new UnaryFormula(new FaultFormula(fault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
var formulaToCheck = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFormula), UnaryOperator.Finally, 25);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
Console.Write($"Probability of formulaToCheck: {result}");
}
}
public void StepwiseProbablityOfLabel2ForExample4()
{
var example = new Example4();
var dtmc = example.MarkovChain;
var results = new List <Probability>();
using (var prismChecker = new BuiltinDtmcModelChecker(dtmc, Output.TextWriterAdapter()))
{
for (var i = 0; i <= 10; i++)
{
var boundedStepi = new BoundedUnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally, i);
var resultBoundedStepi = prismChecker.CalculateProbability(boundedStepi);
Output.Log($"Result {i}:\t{resultBoundedStepi}");
results.Add(resultBoundedStepi);
}
var boundedStep200 = new BoundedUnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally, 200);
var resultBoundedStep200 = prismChecker.CalculateProbability(boundedStep200);
Output.Log($"Result {200}:\t{resultBoundedStep200}");
var inf = new UnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally);
var resultInf = prismChecker.CalculateProbability(inf);
Output.Log($"Result inf:\t{resultInf}");
}
}
public void Check()
{
var m = new SharedModels.SimpleExample2a();
Probability minProbabilityOfFinal0;
Probability minProbabilityOfFinal0Lt;
Probability minProbabilityOfFinal1;
Probability minProbabilityOfFinal2;
Probability maxProbabilityOfFinal0;
Probability maxProbabilityOfFinal0Lt;
Probability maxProbabilityOfFinal1;
Probability maxProbabilityOfFinal2;
var final0Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs0, UnaryOperator.Finally, 4);
var final0LtFormula =
new BoundedUnaryFormula(
new BinaryFormula(SharedModels.SimpleExample2a.StateIs0, BinaryOperator.And, SharedModels.SimpleExample2a.LocalVarIsTrue),
UnaryOperator.Finally, 4);
var final1Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs1, UnaryOperator.Finally, 4);
var final2Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs2, UnaryOperator.Finally, 4);
var nmdpGenerator = new SimpleNmdpFromExecutableModelGenerator(m);
nmdpGenerator.Configuration.WriteGraphvizModels = true;
nmdpGenerator.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
nmdpGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
nmdpGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
nmdpGenerator.AddFormulaToCheck(final0Formula);
nmdpGenerator.AddFormulaToCheck(final0LtFormula);
nmdpGenerator.AddFormulaToCheck(final1Formula);
nmdpGenerator.AddFormulaToCheck(final2Formula);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess();
var typeOfModelChecker = typeof(BuiltinNmdpModelChecker);
var modelChecker = (NmdpModelChecker)Activator.CreateInstance(typeOfModelChecker, nmdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinal0 = modelChecker.CalculateMinimalProbability(final0Formula);
minProbabilityOfFinal0Lt = modelChecker.CalculateMinimalProbability(final0LtFormula);
minProbabilityOfFinal1 = modelChecker.CalculateMinimalProbability(final1Formula);
minProbabilityOfFinal2 = modelChecker.CalculateMinimalProbability(final2Formula);
maxProbabilityOfFinal0 = modelChecker.CalculateMaximalProbability(final0Formula);
maxProbabilityOfFinal0Lt = modelChecker.CalculateMaximalProbability(final0LtFormula);
maxProbabilityOfFinal1 = modelChecker.CalculateMaximalProbability(final1Formula);
maxProbabilityOfFinal2 = modelChecker.CalculateMaximalProbability(final2Formula);
}
minProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal0Lt.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal1.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal2.Is(0.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0Lt.Is(1.0, 0.000001).ShouldBe(true);
var maxProbabilityOf1And2Calculated = 1.0 - Math.Pow(0.6, 4);
maxProbabilityOfFinal1.Is(maxProbabilityOf1And2Calculated, 0.000001).ShouldBe(true);
maxProbabilityOfFinal2.Is(maxProbabilityOf1And2Calculated, 0.000001).ShouldBe(true);
}
public void ProbabilityToReachIn10Steps_Label1(MarkovChainExample example)
{
var dtmc = example.MarkovChain;
var finallyLabel1 = new BoundedUnaryFormula(MarkovChainExample.Label1Formula, UnaryOperator.Finally, 10);
using (var prismChecker = new BuiltinDtmcModelChecker(dtmc, Output.TextWriterAdapter()))
{
var result = prismChecker.CalculateProbability(finallyLabel1);
result.Is(example.ProbabilityFinally10Label1, 0.0001).ShouldBe(true);
}
}
private void CheckBounded(AnalysisConfiguration configuration)
{
var m = new SharedModels.SimpleExample2a();
Probability minProbabilityOfFinal0;
Probability minProbabilityOfFinal0Lt;
Probability minProbabilityOfFinal1;
Probability minProbabilityOfFinal2;
Probability maxProbabilityOfFinal0;
Probability maxProbabilityOfFinal0Lt;
Probability maxProbabilityOfFinal1;
Probability maxProbabilityOfFinal2;
var final0Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs0, UnaryOperator.Finally, 4);
var final0LtFormula =
new BoundedUnaryFormula(
new BinaryFormula(SharedModels.SimpleExample2a.StateIs0, BinaryOperator.And, SharedModels.SimpleExample2a.LocalVarIsTrue),
UnaryOperator.Finally, 4);
var final1Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs1, UnaryOperator.Finally, 4);
var final2Formula = new BoundedUnaryFormula(SharedModels.SimpleExample2a.StateIs2, UnaryOperator.Finally, 4);
var mdpGenerator = new SimpleMarkovDecisionProcessFromExecutableModelGenerator(m);
mdpGenerator.Configuration = configuration;
mdpGenerator.AddFormulaToCheck(final0Formula);
mdpGenerator.AddFormulaToCheck(final0LtFormula);
mdpGenerator.AddFormulaToCheck(final1Formula);
mdpGenerator.AddFormulaToCheck(final2Formula);
var mdp = mdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var modelChecker = new ConfigurationDependentLtmdpModelChecker(configuration, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinal0 = modelChecker.CalculateMinimalProbability(final0Formula);
minProbabilityOfFinal0Lt = modelChecker.CalculateMinimalProbability(final0LtFormula);
minProbabilityOfFinal1 = modelChecker.CalculateMinimalProbability(final1Formula);
minProbabilityOfFinal2 = modelChecker.CalculateMinimalProbability(final2Formula);
maxProbabilityOfFinal0 = modelChecker.CalculateMaximalProbability(final0Formula);
maxProbabilityOfFinal0Lt = modelChecker.CalculateMaximalProbability(final0LtFormula);
maxProbabilityOfFinal1 = modelChecker.CalculateMaximalProbability(final1Formula);
maxProbabilityOfFinal2 = modelChecker.CalculateMaximalProbability(final2Formula);
}
minProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal0Lt.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal1.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal2.Is(0.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0Lt.Is(1.0, 0.000001).ShouldBe(true);
var maxProbabilityOf1And2Calculated = 1.0 - Math.Pow(0.6, 4);
maxProbabilityOfFinal1.Is(maxProbabilityOf1And2Calculated, 0.000001).ShouldBe(true);
maxProbabilityOfFinal2.Is(maxProbabilityOf1And2Calculated, 0.000001).ShouldBe(true);
}
public void MaximalProbabilityToReachIn50Steps_Label1(NestedMarkovDecisionProcessExample example)
{
var nmdp = example.Nmdp;
var steps = 50;
var finallyLabel1 = new BoundedUnaryFormula(NestedMarkovDecisionProcessExample.Label1Formula, UnaryOperator.Finally, steps);
using (var checker = new BuiltinNmdpModelChecker(nmdp, Output.TextWriterAdapter()))
{
var result = checker.CalculateMaximalProbability(finallyLabel1);
result.Is(example.MaximalProbabilityFinallyLabel1, 0.0001).ShouldBe(true);
}
}
public void TankRupture()
{
Formula invariant = new LustrePressureBelowThreshold();
Formula hazard = new UnaryFormula(invariant, UnaryOperator.Not);
LustrePressureBelowThreshold.threshold = 60;
var faults = new List <Fault>
{
new TransientFault()
{
Name = "fault_switch", Identifier = 0, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k1", Identifier = 1, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k2", Identifier = 2, ProbabilityOfOccurrence = null
},
new PermanentFault()
{
Name = "fault_timer", Identifier = 3, ProbabilityOfOccurrence = new Probability(1.0E-5)
},
new PermanentFault()
{
Name = "fault_sensor", Identifier = 4, ProbabilityOfOccurrence = new Probability(1.0E-5)
}
};
var createModel = LustreExecutableModel.CreateExecutedModelFromFormulasCreator(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults.ToArray());
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <LustreExecutableModel>(createModel);
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(10000, 1000000);
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = true;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
markovChainGenerator.AddFormulaToCheck(hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var ltmcModelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, Console.Out);
var finallyHazard = new BoundedUnaryFormula(hazard, UnaryOperator.Finally, 200);
var result = ltmcModelChecker.CalculateProbabilityRange(finallyHazard);
Console.Write($"Probability of hazard: {result}");
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var model = new Model();
SetProbabilities(model);
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;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var onceUnsuccessful = new UnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Once);
var onceContamination = new UnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
foreach (var fault in model.Faults.Where(fault => fault != model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault))
{
var faultFormula = new UnaryFormula(new FaultFormula(fault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
var finallyUnsuccessful = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceUnsuccessful), UnaryOperator.Finally, 6);
var finallyContamination = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceContamination), UnaryOperator.Finally, 6);
markovChainGenerator.AddFormulaToCheck(finallyUnsuccessful);
markovChainGenerator.AddFormulaToCheck(finallyContamination);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyUnsuccessful);
Console.Write($"Probability of unsuccessful: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyContamination);
Console.Write($"Probability of contamination: {result}");
}
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
var model = Model.CreateOriginal();
model.VehicleSet.LeftHV.ProbabilityOfOccurrence = null;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(3300000L, 1000000000L);
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
var collision = new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50);
var falseAlarm = new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(collision);
markovChainGenerator.AddFormulaToCheck(falseAlarm);
/*
* foreach (var fault in model.Faults)
* {
* var faultFormula = new FaultFormula(fault);
* markovChainGenerator.AddFormulaToCheck(faultFormula);
* }
*/
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(collision);
Console.Write($"Probability of collision: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(falseAlarm);
Console.Write($"Probability of falseAlarm: {result}");
}
}
public void CalculateHazardSingleCoreWithOncePositionDetectorMis()
{
var model = Model.CreateOriginal();
SetProbabilities(model);
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(3300000L, 1000000000L);
var onceFault1 = new UnaryFormula(new FaultFormula(model.HeightControl.PreControl.PositionDetector.Misdetection), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
var onceCollision = new UnaryFormula(model.Collision, UnaryOperator.Once);
var onceFalseAlarm = new UnaryFormula(model.FalseAlarm, UnaryOperator.Once);
var finallyCollision = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceCollision), UnaryOperator.Finally, 50);
var finallyFalseAlarm = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFalseAlarm), UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(finallyCollision);
markovChainGenerator.AddFormulaToCheck(finallyFalseAlarm);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var markovChain = markovChainGenerator.GenerateMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyCollision);
Console.Write($"Probability of collision: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyFalseAlarm);
Console.Write($"Probability of falseAlarm: {result}");
}
}
public void TankRupture()
{
Formula invariant = new LustrePressureBelowThreshold();
Formula hazard = new UnaryFormula(invariant, UnaryOperator.Not);
LustrePressureBelowThreshold.threshold = 60;
var faults = new List <Fault>
{
new TransientFault()
{
Name = "fault_switch", Identifier = 0, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k1", Identifier = 1, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k2", Identifier = 2, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_timer", Identifier = 3, ProbabilityOfOccurrence = new Probability(1.0E-5)
},
new PermanentFault()
{
Name = "fault_sensor", Identifier = 4, ProbabilityOfOccurrence = new Probability(1.0E-5)
}
};
var modelChecker = new LustreMarkovChainFromExecutableModelGenerator(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults);
modelChecker.AddFormulaToCheck(hazard);
modelChecker.Configuration.UseCompactStateStorage = true;
var lmc = modelChecker.GenerateLabeledMarkovChain();
var ltmcModelChecker = new BuiltinLtmcModelChecker(lmc, Console.Out);
var finallyHazard = new BoundedUnaryFormula(hazard, UnaryOperator.Finally, 200);
var result = ltmcModelChecker.CalculateProbability(finallyHazard);
Console.Write($"Probability of hazard: {result}");
}
private void CheckSmallerEqualTwo(AnalysisConfiguration configuration)
{
var m = new Model();
Probability minProbabilityOfFinalSmallerEqual2;
Probability maxProbabilityOfFinalSmallerEqual2;
var finalSmallerEqual2Formula = new BoundedUnaryFormula(new SimpleStateInRangeFormula(0, 2), UnaryOperator.Finally, 5);
var mdpGenerator = new SimpleMarkovDecisionProcessFromExecutableModelGenerator(m);
mdpGenerator.Configuration = configuration;
mdpGenerator.AddFormulaToCheck(finalSmallerEqual2Formula);
var mdp = mdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var modelChecker = new ConfigurationDependentLtmdpModelChecker(configuration, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinalSmallerEqual2 = modelChecker.CalculateMinimalProbability(finalSmallerEqual2Formula);
maxProbabilityOfFinalSmallerEqual2 = modelChecker.CalculateMaximalProbability(finalSmallerEqual2Formula);
}
}
public void CalculateHazardSingleCore()
{
var model = new Model();
SetProbabilities(model);
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;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var unsuccessful = new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6);
var contamination = new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6);
markovChainGenerator.AddFormulaToCheck(unsuccessful);
markovChainGenerator.AddFormulaToCheck(contamination);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(unsuccessful);
Console.Write($"Probability of collision: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(contamination);
Console.Write($"Probability of collision: {result}");
}
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
var model = new DegradedModeModel();
model.System.SignalDetector1.F1.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.System.HazardActive);
var formulaToCheck = new BoundedUnaryFormula(formula, UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
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}");
}
}
/// <summary> /// Visits the <paramref name="formula." /> /// </summary> public abstract void VisitBoundedUnaryFormula(BoundedUnaryFormula formula);
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBoundedUnaryFormula(BoundedUnaryFormula formula)
{
throw new NotImplementedException();
}
/// <summary>
/// Calculates the probability to reach a state where <paramref name="stateFormula" /> holds.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="stateFormula">The state formula to be checked.</param>
/// <param name="bound">The maximal number of steps. If stateFormula is satisfied the first time any step later than bound, this probability does not count into the end result.</param>
public static Probability CalculateProbabilityToReachStateBounded(string ocFileName, string mainNode, IEnumerable <Fault> faults, Formula stateFormula, int bound)
{
var formula = new BoundedUnaryFormula(stateFormula, UnaryOperator.Finally, bound);
return(CalculateProbabilityOfFormula(ocFileName, mainNode, faults, formula));
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBoundedUnaryFormula(BoundedUnaryFormula formula)
{
_containsInvalidOperators = true;
}
/// <summary>
/// Calculates the probability to reach a state whether <paramref name="stateFormula" /> holds.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="stateFormula">The state formula which _must_ finally be true.</param>
/// <param name="bound">The maximal number of steps. If stateFormula is satisfied the first time any step later than bound, this probability does not count into the end result.</param>
public static ProbabilityRange CalculateProbabilityRangeToReachStateBounded(ModelBase model, Formula stateFormula, int bound)
{
var formula = new BoundedUnaryFormula(stateFormula, UnaryOperator.Finally, bound);
return(CalculateProbabilityRangeOfFormulaBounded(model, formula, stateFormula, bound));
}