protected override void Check()
{
var c = new C();
var directModel = InitializeModel(c);
((C.Effect1)c.FaultEffects[0]).F = 17;
_hasConstructorRun = false;
var newModelInstanceBySerializeDeserialize = SafetySharpRuntimeModel.CreateExecutedModelCreator(directModel).Create(0);
//"Create" serializes and deserializes again (second time)
Create(newModelInstanceBySerializeDeserialize.Model);
ExecutableStateFormulas.ShouldBeEmpty();
RootComponents.Length.ShouldBe(1);
var root = RootComponents[0];
root.ShouldBeOfType <C.Effect1>();
root.GetSubcomponents().ShouldBeEmpty();
((C)root).F1.ShouldBeOfType <TransientFault>();
((C.Effect1)root).F.ShouldBe(17);
root.FaultEffects.Count.ShouldBe(1);
((C.Effect1)root.FaultEffects[0]).F.ShouldBe(17);
typeof(C.Effect1).GetField("__fault__", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(root).ShouldBe(((C)root).F1);
_hasConstructorRun.ShouldBe(false);
}
/// <summary>
/// Calculates the probability of formula.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="formula">The state formula to be checked.</param>
/// <param name="terminateEarlyFormula">When terminateEarlyFormula is satisfied stop building the state space.</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 CalculateProbabilityRangeOfFormulaBounded(ModelBase model, Formula formula, Formula terminateEarlyFormula, int bound)
{
ProbabilityRange probabilityRangeToReachState;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var nmdpGenerator = new NmdpFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
nmdpGenerator.AddFormulaToCheck(formula);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess(terminateEarlyFormula);
if (_convertNmdpToMdp)
{
var nmdpToMpd = new NmdpToMdp(nmdp);
var mdp = nmdpToMpd.MarkovDecisionProcess;
using (var modelChecker = new BuiltinMdpModelChecker(mdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
}
else
{
using (var modelChecker = new BuiltinNmdpModelChecker(nmdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
}
return(probabilityRangeToReachState);
}
/// <summary>
/// Checks whether the <paramref name="formula" /> holds in all states of the <paramref name="model" />. The appropriate model
/// checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="formula">The formula that should be checked.</param>
public static SafetySharpInvariantAnalysisResult Check(ModelBase model, Formula formula)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, formula);
var result = new LtsMin().Check(createModel, formula);
return(SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
}
public void CreateMarkovChainWithBothHazardsRetraversal2()
{
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.AddFormulaToCheck(new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6));
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(new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6));
retraversalMarkovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6));
retraversalMarkovChainGenerator.Configuration.UseCompactStateStorage = true;
retraversalMarkovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
retraversalMarkovChainGenerator.GenerateLabeledMarkovChain();
}
public void CalculateLtmdpWithoutStaticPruning()
{
var model = new Model();
SetProbabilities(model);
model.Channel.MessageDropped.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;
markovChainGenerator.AddFormulaToCheck(model.PossibleCollision);
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.GenerateLabeledTransitionMarkovDecisionProcess();
}
public void CalculateMdpFlattenedWithoutFaults()
{
var model = new Model();
SetProbabilities(model);
model.Channel.MessageDropped.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.BuildInMdpWithNewStates;
markovChainGenerator.AddFormulaToCheck(model.PossibleCollision);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var nmdp = markovChainGenerator.GenerateNestedMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdpByFlattening(nmdp);
}
public void CalculateLtmdpWithoutStaticPruning()
{
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;
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50));
/*
* 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.GenerateLabeledTransitionMarkovDecisionProcess();
}
public void CalculateMdpFlattenedWithoutFaults()
{
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.BuildInMdpWithNewStates;
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var nmdp = markovChainGenerator.GenerateNestedMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdpByFlattening(nmdp);
}
public void CalculateHazardSingleCoreAllFaults()
{
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);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateMarkovChain();
}
public void CreateMarkovChainWithBothHazardsRetraversal1()
{
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.AddFormulaToCheck(new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
var retraversalMarkovChainGenerator = new MarkovChainFromMarkovChainGenerator(markovChain);
retraversalMarkovChainGenerator.Configuration.SuccessorCapacity *= 2;
retraversalMarkovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.Collision, UnaryOperator.Finally, 50));
retraversalMarkovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.FalseAlarm, UnaryOperator.Finally, 50));
retraversalMarkovChainGenerator.Configuration.UseCompactStateStorage = true;
retraversalMarkovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
retraversalMarkovChainGenerator.GenerateLabeledMarkovChain();
}
public void CalculateMdpNewStatesConstant()
{
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 NmdpToMdpByNewStates(nmdp, markovChainGenerator.Configuration.DefaultTraceOutput, true);
}
public void CreateFaultAwareMarkovChainAllFaults()
{
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.EnableEarlyTermination = false;
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateMarkovChain();
}
protected bool CheckInvariant(Formula invariant, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var logAction = (Action <string>)(message => Output.Log("{0}", message));
analysisTestsVariant.CreateModelChecker(SuppressCounterExampleGeneration, logAction);
var model = TestModel.InitializeModel(components);
var useCheckInvariantsInsteadOfCheckInvariant = Arguments.Length > 1 && (bool)Arguments[1];
if (useCheckInvariantsInsteadOfCheckInvariant)
{
var modelFromFormulasGenerator = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var results = analysisTestsVariant.CheckInvariants(modelFromFormulasGenerator, invariant);
CounterExample = results[0].CounterExample;
return(results[0].FormulaHolds);
}
var modelGenerator = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
Result = analysisTestsVariant.CheckInvariant(modelGenerator, invariant);
CounterExample = Result.CounterExample;
return(Result.FormulaHolds);
}
public void CalculateMdpFlattenedWithoutFaults()
{
var model = new Model();
SetProbabilities(model);
model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault.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.Configuration.EnableEarlyTermination = false;
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6));
markovChainGenerator.AddFormulaToCheck(new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6));
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var nmdp = markovChainGenerator.GenerateNestedMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdpByFlattening(nmdp);
}
public void CreateFaultAwareMarkovChainAllFaults()
{
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.AddFormulaToCheck(model.PossibleCollision);
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 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 CalculateMdpFlattened()
{
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.BuildInMdpWithNewStates;
markovChainGenerator.AddFormulaToCheck(model.System.HazardActive);
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 CreateMarkovChainWithHazardsRetraversal2()
{
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.AddFormulaToCheck(model.PossibleCollision);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
var retraversalMarkovChainGenerator = new MarkovChainFromMarkovChainGenerator(markovChain);
retraversalMarkovChainGenerator.Configuration.SuccessorCapacity *= 2;
retraversalMarkovChainGenerator.AddFormulaToCheck(model.PossibleCollision);
retraversalMarkovChainGenerator.Configuration.UseCompactStateStorage = true;
retraversalMarkovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
retraversalMarkovChainGenerator.GenerateLabeledMarkovChain();
}
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}");
}
}
public void CreateMarkovChainWithHazardRetraversal1()
{
var model = new DegradedModeModel();
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(model.System.HazardActive);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
var retraversalMarkovChainGenerator = new MarkovChainFromMarkovChainGenerator(markovChain);
retraversalMarkovChainGenerator.Configuration.SuccessorCapacity *= 2;
retraversalMarkovChainGenerator.AddFormulaToCheck(model.System.HazardActive);
retraversalMarkovChainGenerator.Configuration.UseCompactStateStorage = true;
retraversalMarkovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = true;
retraversalMarkovChainGenerator.GenerateLabeledMarkovChain();
}
protected void GenerateStateSpace(params IComponent[] components)
{
_modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), new ExecutableStateFormula(() => true));
var configuration = AnalysisConfiguration.Default;
configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
configuration.StackCapacity = 10000;
configuration.CpuCount = 1;
configuration.DefaultTraceOutput = Output.TextWriterAdapter();
configuration.AllowFaultsOnInitialTransitions = AllowFaultsOnInitialTransitions;
var analysisModelCreator = new AnalysisModelCreator(() => new ActivationMinimalExecutedModel <SafetySharpRuntimeModel>(_modelCreator, 0, configuration));
var checker = new InvariantChecker(analysisModelCreator,
configuration,
formulaIndex: 0);
_result = checker.Check();
CounterExample.ShouldBe(null);
Output.Log($"States: {_result.StateCount}");
Output.Log($"Actual Transitions: {_result.TransitionCount}");
Output.Log($"Computed Transitions: {_result.ComputedTransitionCount}");
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
public static AnalysisResult <SafetySharpRuntimeModel> CheckInvariant(ModelBase model, Formula invariant)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel> {
Configuration = TraversalConfiguration
};
return(qualitativeChecker.CheckInvariant(createModel, formulaIndex: 0));
}
/// <summary>
/// Checks whether the <paramref name="invariants" /> hold in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariants">The invariants that should be checked.</param>
public static AnalysisResult <SafetySharpRuntimeModel>[] CheckInvariants(ModelBase model, params Formula[] invariants)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel> {
Configuration = TraversalConfiguration
};
return(qualitativeChecker.CheckInvariants(createModel, invariants));
}
protected override void Check()
{
var m = new S();
var r = SafetySharpRuntimeModel.Create(m);
r.RootComponents.Length.ShouldBe(4);
r.RootComponents[0].ShouldBeOfType <D>();
r.RootComponents[1].ShouldBeOfType <F>();
r.RootComponents[2].ShouldBeOfType <C>();
r.RootComponents[3].ShouldBeOfType <E>();
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
public static SafetySharpInvariantAnalysisResult CheckInvariant(ModelBase model, Formula invariant)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariant);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
var result = qualitativeChecker.CheckInvariant(formulaIndex: 0);
return(SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
}
/// <summary>
/// Checks whether the <paramref name="invariants" /> hold in all states of the <paramref name="model" />. The appropriate
/// model checker is chosen automatically.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="invariants">The invariants that should be checked.</param>
public static SafetySharpInvariantAnalysisResult[] CheckInvariants(ModelBase model, params Formula[] invariants)
{
var createModel = SafetySharpRuntimeModel.CreateExecutedModelCreator(model, invariants);
var qualitativeChecker = new QualitativeChecker <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
var results = qualitativeChecker.CheckInvariants(invariants);
var newResults = results.Select(result => SafetySharpInvariantAnalysisResult.FromInvariantAnalysisResult(result, createModel));
return(newResults.ToArray());
}
protected bool Check(Formula formula, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), formula);
analysisTestsVariant.SetModelCheckerParameter(SuppressCounterExampleGeneration, Output.TextWriterAdapter());
analysisTestsVariant.SetExecutionParameter(AllowFaultsOnInitialTransitions);
var result = analysisTestsVariant.Check(modelCreator, formula);
CounterExample = result.ExecutableCounterExample(modelCreator);
return(result.FormulaHolds);
}
protected bool[] CheckInvariants(IComponent component, params Formula[] invariants)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(component), invariants);
analysisTestsVariant.SetModelCheckerParameter(SuppressCounterExampleGeneration, Output.TextWriterAdapter());
analysisTestsVariant.SetExecutionParameter(AllowFaultsOnInitialTransitions);
var results = analysisTestsVariant.CheckInvariants(modelCreator, invariants);
CounterExamples = results.Select(result => result.ExecutableCounterExample(modelCreator)).ToArray();
return(results.Select(result => result.FormulaHolds).ToArray());
}
protected bool Check(Formula formula, params IComponent[] components)
{
var analysisTestsVariant = (AnalysisTestsVariant)Arguments[0];
var logAction = (Action <string>)(message => Output.Log("{0}", message));
analysisTestsVariant.CreateModelChecker(SuppressCounterExampleGeneration, logAction);
var modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), formula);
var result = analysisTestsVariant.Check(modelCreator, formula);
CounterExample = result.CounterExample;
return(result.FormulaHolds);
}
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}");
}
}
