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 CalculateMdpFlattened()
{
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.BuildInMdpWithFlattening;
markovChainGenerator.AddFormulaToCheck(_hazard);
foreach (var fault in _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);
_faults[1].ProbabilityOfOccurrence = oldProbability;
}
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 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 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 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}");
}
}
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 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 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 CalculateLtmdpWithoutFaultsWithPruning()
{
var oldProbability = _faults[1].ProbabilityOfOccurrence;
_faults[1].ProbabilityOfOccurrence = null;
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <LustreExecutableModel>(_createModel);
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();
_faults[1].ProbabilityOfOccurrence = oldProbability;
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
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.BuiltInLtmdp;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var unsuccessful = new UnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally);
var contamination = new UnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally);
markovChainGenerator.AddFormulaToCheck(unsuccessful);
markovChainGenerator.AddFormulaToCheck(contamination);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.CpuCount = 1;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(unsuccessful);
Console.Write($"Probability of unsuccessful: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(contamination);
Console.Write($"Probability of contamination: {result}");
}
}
public void CalculateMdpNewStatesConstantWithoutFaults()
{
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.BuildInMdpWithNewStatesConstantDistance;
markovChainGenerator.AddFormulaToCheck(_hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var nmdp = markovChainGenerator.GenerateNestedMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdpByNewStates(nmdp, markovChainGenerator.Configuration.DefaultTraceOutput, true);
_faults[1].ProbabilityOfOccurrence = oldProbability;
}
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 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>
/// 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>
public static ProbabilityRange CalculateProbabilityRangeOfFormula(ModelBase model, Formula formula)
{
ProbabilityRange probabilityRangeToReachState;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var ltmdpGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
ltmdpGenerator.AddFormulaToCheck(formula);
ltmdpGenerator.Configuration.SuccessorCapacity *= 8;
ltmdpGenerator.Configuration.UseCompactStateStorage = true;
var ltmdp = ltmdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(ltmdpGenerator.Configuration, ltmdp, TraversalConfiguration.DefaultTraceOutput))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
System.GC.Collect();
return(probabilityRangeToReachState);
}
/// <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>
public static ProbabilityRange CalculateProbabilityRangeOfFormula(string ocFileName, string mainNode, IEnumerable <Fault> faults, Formula formula)
{
ProbabilityRange probabilityRangeToReachState;
var createModel = LustreExecutableModel.CreateExecutedModelFromFormulasCreator(ocFileName, mainNode, faults.ToArray());
var ltmdpGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <LustreExecutableModel>(createModel)
{
Configuration = TraversalConfiguration
};
ltmdpGenerator.AddFormulaToCheck(formula);
ltmdpGenerator.Configuration.SuccessorCapacity *= 8;
ltmdpGenerator.Configuration.UseCompactStateStorage = true;
var ltmdp = ltmdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(ltmdpGenerator.Configuration, ltmdp, TraversalConfiguration.DefaultTraceOutput))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
GC.Collect();
return(probabilityRangeToReachState);
}
