/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> /// <param name="stateFormula">The analyzed stateFormula.</param> internal InvariantChecker(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, Formula stateFormula) : base(createModel, output, configuration, 0) { var formulasToCheck = AnalyzedModels.First().RuntimeModel.Formulas; Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationAction <TExecutableModel>(formulasToCheck, stateFormula)); }
/// <summary> /// Generates a <see cref="LabeledTransitionMarkovDecisionProcess" /> for the model created by <paramref name="createModel" />. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> internal LabeledTransitionMarkovDecisionProcess GenerateLtmdp(AnalysisModelCreator createModel) { using (var modelTraverser = new ModelTraverser(createModel, Configuration, LabeledTransitionMarkovDecisionProcess.TransitionSize, FormulaManager.NeedsStutteringState)) { _mdp = new LabeledTransitionMarkovDecisionProcess(modelTraverser.Context.ModelCapacity.NumberOfStates, modelTraverser.Context.ModelCapacity.NumberOfTransitions); _mdp.StateFormulaLabels = FormulaManager.FinalStateFormulaLabels.ToArray(); if (FormulaManager.NeedsStutteringState) { _mdp.CreateStutteringState(modelTraverser.Context.StutteringStateIndex); } modelTraverser.Context.TraversalParameters.TransitionModifiers.AddRange(FormulaManager.TransitionModifierGenerators); modelTraverser.Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovDecisionProcess.LtmdpBuilderDuringTraversal(_mdp)); modelTraverser.Context.Output.WriteLine("Generating labeled transition markov decision process."); modelTraverser.TraverseModelAndReport(); // StateStorage must be freed manually. Reason is that invariant checker does not free up the // space, because it might be necessary for other usages of the ModelTraversers (e.g. StateGraphGenerator // which keeps the States for the StateGraph) modelTraverser.Context.States.SafeDispose(); } if (Configuration.WriteGraphvizModels) { FormulaManager.PrintStateFormulas(FormulaManager.FinalStateFormulas, Configuration.DefaultTraceOutput); Configuration.DefaultTraceOutput.WriteLine("Ltmdp Model"); _mdp.ExportToGv(Configuration.DefaultTraceOutput); } return(_mdp); }
/// <summary> /// Initializes the model that should be analyzed. /// </summary> /// <param name="configuration">The configuration that should be used for the analyses.</param> /// <param name="hazard">The hazard that should be analyzed.</param> protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard) { var invariant = new UnaryFormula(hazard, UnaryOperator.Not); var checker = new QualitativeChecker <TExecutableModel>(RuntimeModelCreator) { Configuration = configuration }; checker.Configuration.ProgressReportsOnly = false; var stateGraph = checker.GenerateStateGraph(); var stateCapacity = Math.Max(1024, (int)(stateGraph.StateCount * 1.5)); var newModelCapacity = new ModelCapacityByModelDensity(stateCapacity, ModelDensityLimit.High); configuration.ModelCapacity = newModelCapacity; Func <AnalysisModel> createAnalysisModelFunc = () => new StateGraphModel <TExecutableModel>(stateGraph, configuration.SuccessorCapacity); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); _checker = new InvariantChecker(createAnalysisModel, configuration, invariant); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="configuration">The analysis configuration that should be used.</param> /// <param name="stateFormula">The analyzed stateFormula.</param> internal InvariantChecker(AnalysisModelCreator createModel, AnalysisConfiguration configuration, Formula stateFormula) { ModelTraverser = new ModelTraverser(createModel, configuration, 0, false); var formulasToCheck = ModelTraverser.AnalyzedModels.First().Formulas; ModelTraverser.Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationAction(formulasToCheck, stateFormula)); }
/// <summary> /// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />. /// </summary> public NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(Formula terminateEarlyCondition = null) { Requires.That(IntPtr.Size == 8, "Model checking is only supported in 64bit processes."); ProbabilityMatrixCreationStarted = true; CollectStateFormulasVisitor stateFormulaCollector; if (Configuration.UseAtomarPropositionsAsStateLabels) { stateFormulaCollector = new CollectAtomarPropositionFormulasVisitor(); } else { stateFormulaCollector = new CollectMaximalCompilableFormulasVisitor(); } foreach (var stateFormula in _formulasToCheck) { stateFormulaCollector.VisitNewTopLevelFormula(stateFormula); } if (terminateEarlyCondition) { stateFormulaCollector.VisitNewTopLevelFormula(terminateEarlyCondition); } var stateFormulas = stateFormulaCollector.CollectedStateFormulas.ToArray(); ExecutedModel <TExecutableModel> model = null; var modelCreator = _runtimeModelCreator.CreateCoupledModelCreator(stateFormulas); Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () => model = new LtmdpExecutedModel <TExecutableModel>(modelCreator, 0, Configuration.SuccessorCapacity); var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc); return(GenerateMarkovDecisionProcess(createAnalysisModel, terminateEarlyCondition, stateFormulas)); }
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> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal ModelTraverser(AnalysisModelCreator createModel, AnalysisConfiguration configuration, int transitionSize, bool createStutteringState) { Requires.NotNull(createModel, nameof(createModel)); var stopwatch = new Stopwatch(); stopwatch.Start(); TransitionCollection.ValidateTransitionSizes(); var tasks = new Task[configuration.CpuCount]; var stacks = new StateStack[configuration.CpuCount]; _loadBalancer = new LoadBalancer(stacks); Context = new TraversalContext(_loadBalancer, configuration); _workers = new Worker[configuration.CpuCount]; for (var i = 0; i < configuration.CpuCount; ++i) { var index = i; tasks[i] = Task.Factory.StartNew(() => { stacks[index] = new StateStack(configuration.StackCapacity); _workers[index] = new Worker(index, Context, stacks[index], createModel.Create()); }); } Task.WaitAll(tasks); var firstModel = _workers[0].Model; if (transitionSize == DeriveTransitionSizeFromModel) { transitionSize = firstModel.TransitionSize; } if (configuration.WriteStateVectorLayout) { firstModel.WriteStateVectorLayout(configuration.DefaultTraceOutput); } var modelCapacity = configuration.ModelCapacity.DeriveModelByteSize(firstModel.ModelStateVectorSize, transitionSize); Context.ModelCapacity = modelCapacity; if (configuration.UseCompactStateStorage) { _states = new CompactStateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates); } else { _states = new SparseStateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates); } Context.States = _states; if (createStutteringState) { Context.StutteringStateIndex = _states.ReserveStateIndex(); } _initializationTime = stopwatch.Elapsed; stopwatch.Stop(); }
public void AnalysisModelCreatorsAreIndependent() { var other = new AnalysisModelCreator(); var f1 = other.GetFactory <TestAnalysisCircuitModel>(); var f2 = creator.GetFactory <TestAnalysisCircuitModel>(); Assert.NotEqual(f1, f2); }
/// <summary> /// Initizializes the model that should be analyzed. /// </summary> /// <param name="configuration">The configuration that should be used for the analyses.</param> /// <param name="hazard">The hazard that should be analyzed.</param> protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard) { Func <AnalysisModel> createAnalysisModelFunc = () => new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, 0, configuration); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); var invariant = new UnaryFormula(hazard, UnaryOperator.Not); _invariantChecker = new InvariantChecker(createAnalysisModel, configuration, invariant); }
/// <summary> /// Initizializes the model that should be analyzed. /// </summary> /// <param name="configuration">The configuration that should be used for the analyses.</param> /// <param name="hazard">The hazard that should be analyzed.</param> protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard) { Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () => new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, _stateHeaderBytes, configuration.SuccessorCapacity); var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc); var invariant = new UnaryFormula(hazard, UnaryOperator.Not); _invariantChecker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OnOutputWritten, configuration, invariant); }
/// <summary> /// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />. /// </summary> private NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas) { using (var checker = new LtmdpGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration)) { var ltmdp = checker.GenerateStateGraph(); var ltmdpToNmdp = new LtmdpToNmdp(ltmdp); var nmdp = ltmdpToNmdp.NestedMarkovDecisionProcess; return(nmdp); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal StateGraphGenerator(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration) : base(createModel, output, configuration, DeriveTransitionSizeFromModel) { var analyzedModel = AnalyzedModels.First(); _stateGraph = new StateGraph <TExecutableModel>( Context, analyzedModel.TransitionSize, analyzedModel.RuntimeModel, analyzedModel.RuntimeModelCreator); Context.TraversalParameters.BatchedTransitionActions.Add(() => new StateGraphBuilder <TExecutableModel>(_stateGraph)); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal StateGraphGenerator(AnalysisModelCreator createModel, AnalysisConfiguration configuration) { _modelTraverser = new ModelTraverser(createModel, configuration, ModelTraverser.DeriveTransitionSizeFromModel, false); var analyzedModel = _modelTraverser.AnalyzedModels.OfType <ExecutedModel <TExecutableModel> >().First(); _stateGraph = new StateGraph <TExecutableModel>( _modelTraverser.Context, analyzedModel.TransitionSize, analyzedModel.RuntimeModel, analyzedModel.RuntimeModelCreator); _modelTraverser.Context.TraversalParameters.BatchedTransitionActions.Add(() => new StateGraphBuilder <TExecutableModel>(_stateGraph)); }
public LabeledTransitionMarkovChain GenerateLabeledMarkovChain() { FormulaManager.Calculate(Configuration); var stateFormulasToCheckInBaseModel = FormulaManager.StateFormulasToCheckInBaseModel.ToArray(); var createModel = new AnalysisModelCreator(() => new LtmcRetraverseModel(_sourceLtmc, stateFormulasToCheckInBaseModel, Configuration)); Configuration.DefaultTraceOutput.WriteLine("Retraverse Model"); var labeledTransitionMarkovChain = GenerateLtmc(createModel); return(labeledTransitionMarkovChain); }
/// <summary> /// Generates a <see cref="StateGraph{TExecutableModel}" /> for the model created by <paramref name="createModel" />. /// </summary> internal StateGraph <TExecutableModel> GenerateStateGraph() { // We have to track the state vector layout here; this will nondeterministically store some model instance of // one of the workers; but since all state vectors are the same, we don't care ExecutedModel <TExecutableModel> model = null; Func <AnalysisModel> createAnalysisModelFunc = () => model = new ActivationMinimalExecutedModel <TExecutableModel>(ModelCreator, 0, Configuration); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); using (var checker = new StateGraphGenerator <TExecutableModel>(createAnalysisModel, Configuration)) { var stateGraph = checker.GenerateStateGraph(); return(stateGraph); } }
/// <summary> /// Checks the invariant encoded into the model created by <paramref name="createModel" />. /// </summary> public InvariantAnalysisResult CheckInvariant(int formulaIndex) { // We have to track the state vector layout here; this will nondeterministically store some model instance of // one of the workers; but since all state vectors are the same, we don't care ExecutedModel <TExecutableModel> model = null; Func <AnalysisModel> createAnalysisModelFunc = () => model = new ActivationMinimalExecutedModel <TExecutableModel>(ModelCreator, 0, Configuration); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); using (var checker = new InvariantChecker(createAnalysisModel, Configuration, formulaIndex)) { var result = checker.Check(); return(result); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="executableStateFormulas">The state formulas that can be evaluated over the generated state graph.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal LtmdpGenerator(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas, Action <string> output, AnalysisConfiguration configuration) : base(createModel, output, configuration, LabeledTransitionMarkovDecisionProcess.TransitionSize) { _mdp = new LabeledTransitionMarkovDecisionProcess(Context.ModelCapacity.NumberOfStates, Context.ModelCapacity.NumberOfTransitions); _mdp.StateFormulaLabels = executableStateFormulas.Select(stateFormula => stateFormula.Label).ToArray(); Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovDecisionProcess.LtmdpBuilderDuringTraversal <TExecutableModel>(_mdp, configuration)); if (terminateEarlyCondition != null) { _mdp.CreateStutteringState(Context.StutteringStateIndex); var terminalteEarlyFunc = StateFormulaSetEvaluatorCompilationVisitor.Compile(_mdp.StateFormulaLabels, terminateEarlyCondition); Context.TraversalParameters.TransitionModifiers.Add(() => new EarlyTerminationModifier <TExecutableModel>(terminalteEarlyFunc)); } }
/// <summary> /// Checks the invariant encoded into the model created by <paramref name="createModel" />. /// </summary> public AnalysisResult <TExecutableModel> CheckInvariant(CoupledExecutableModelCreator <TExecutableModel> createModel, Formula formula) { // We have to track the state vector layout here; this will nondeterministically store some model instance of // one of the workers; but since all state vectors are the same, we don't care ExecutedModel <TExecutableModel> model = null; Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () => model = new ActivationMinimalExecutedModel <TExecutableModel>(createModel, 0, Configuration.SuccessorCapacity); var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc); using (var checker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OutputWritten, Configuration, formula)) { var result = checker.Check(); return(result); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal ModelTraverser(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, int transitionSize) { Requires.NotNull(createModel, nameof(createModel)); Requires.NotNull(output, nameof(output)); var stopwatch = new Stopwatch(); stopwatch.Start(); TransitionCollection.ValidateTransitionSizes(); var tasks = new Task[configuration.CpuCount]; var stacks = new StateStack[configuration.CpuCount]; _loadBalancer = new LoadBalancer(stacks); Context = new TraversalContext <TExecutableModel>(_loadBalancer, configuration, output); _workers = new Worker <TExecutableModel> [configuration.CpuCount]; for (var i = 0; i < configuration.CpuCount; ++i) { var index = i; tasks[i] = Task.Factory.StartNew(() => { stacks[index] = new StateStack(configuration.StackCapacity); _workers[index] = new Worker <TExecutableModel>(index, Context, stacks[index], createModel.Create()); }); } Task.WaitAll(tasks); var firstModel = _workers[0].Model; if (transitionSize == DeriveTransitionSizeFromModel) { transitionSize = firstModel.TransitionSize; } var modelCapacity = configuration.ModelCapacity.DeriveModelByteSize(firstModel.StateVectorSize, transitionSize); Context.ModelCapacity = modelCapacity; _states = new StateStorage(modelCapacity.SizeOfState, modelCapacity.NumberOfStates); Context.States = _states; Context.StutteringStateIndex = _states.ReserveStateIndex(); _initializationTime = stopwatch.Elapsed; stopwatch.Stop(); }
/// <summary> /// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="stateGraph" />. /// </summary> /// <param name="stateGraph">The state graph that should be checked.</param> /// <param name="invariant">The invariant that should be checked.</param> internal InvariantAnalysisResult CheckInvariant(StateGraph <TExecutableModel> stateGraph, Formula invariant) { Requires.NotNull(stateGraph, nameof(stateGraph)); Requires.NotNull(invariant, nameof(invariant)); // We have to track the state vector layout here; this will nondeterministically store some model instance of // one of the workers; but since all state vectors are the same, we don't care AnalysisModel model = null; Func <AnalysisModel> createAnalysisModelFunc = () => model = new StateGraphModel <TExecutableModel>(stateGraph, Configuration.SuccessorCapacity); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); using (var checker = new InvariantChecker(createAnalysisModel, Configuration, invariant)) { var result = checker.Check(); return(result); } }
/// <summary> /// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />. /// </summary> public LabeledTransitionMarkovDecisionProcess GenerateLabeledTransitionMarkovDecisionProcess() { Requires.That(IntPtr.Size == 8, "Model checking is only supported in 64bit processes."); ProbabilityMatrixCreationStarted = true; FormulaManager.Calculate(Configuration); var stateFormulasToCheckInBaseModel = FormulaManager.StateFormulasToCheckInBaseModel.ToArray(); ExecutedModel <TExecutableModel> model = null; var modelCreator = _runtimeModelCreator.CreateCoupledModelCreator(stateFormulasToCheckInBaseModel); Func <AnalysisModel> createAnalysisModelFunc = () => model = new LtmdpExecutedModel <TExecutableModel>(modelCreator, Configuration); var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc); var ltmdp = GenerateLtmdp(createAnalysisModel); return(ltmdp); }
/// <summary> /// Generates a <see cref="MarkovDecisionProcess" /> for the model created by <paramref name="createModel" />. /// </summary> private NestedMarkovDecisionProcess GenerateMarkovDecisionProcess(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas) { using (var checker = new LtmdpGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration)) { PrintStateFormulas(executableStateFormulas); var ltmdp = checker.GenerateStateGraph(); if (Configuration.WriteGraphvizModels) { Configuration.DefaultTraceOutput.WriteLine("Ltmdp Model"); ltmdp.ExportToGv(Configuration.DefaultTraceOutput); } var ltmdpToNmdp = new LtmdpToNmdp(ltmdp); var nmdp = ltmdpToNmdp.NestedMarkovDecisionProcess; if (Configuration.WriteGraphvizModels) { Configuration.DefaultTraceOutput.WriteLine("Nmdp Model"); nmdp.ExportToGv(Configuration.DefaultTraceOutput); } return(nmdp); } }
/// <summary> /// Generates a <see cref="DiscreteTimeMarkovChain" /> for the model created by <paramref name="createModel" />. /// </summary> private DiscreteTimeMarkovChain GenerateMarkovChain(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas) { using (var checker = new LtmcGenerator <TExecutableModel>(createModel, terminateEarlyCondition, executableStateFormulas, OutputWritten, Configuration)) { PrintStateFormulas(executableStateFormulas); var labeledTransitionMarkovChain = checker.GenerateStateGraph(); if (Configuration.WriteGraphvizModels) { Configuration.DefaultTraceOutput.WriteLine("Ltmc Model"); labeledTransitionMarkovChain.ExportToGv(Configuration.DefaultTraceOutput); } var ltmcToMc = new LtmcToDtmc(labeledTransitionMarkovChain); var markovChain = ltmcToMc.MarkovChain; if (Configuration.WriteGraphvizModels) { Configuration.DefaultTraceOutput.WriteLine("Dtmc Model"); markovChain.ExportToGv(Configuration.DefaultTraceOutput); } return(markovChain); } }
public CircuitCalculationTests(ITestOutputHelper output) : base(output) { creator = new AnalysisModelCreator(); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> /// <param name="formulaIndex">The zero-based index of the analyzed formula.</param> internal InvariantChecker(AnalysisModelCreator <TExecutableModel> createModel, Action <string> output, AnalysisConfiguration configuration, int formulaIndex) : base(createModel, output, configuration, 0) { Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationByIndexAction <TExecutableModel>(formulaIndex)); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="configuration">The analysis configuration that should be used.</param> /// <param name="formulaIndex">The zero-based index of the analyzed formula.</param> internal InvariantChecker(AnalysisModelCreator createModel, AnalysisConfiguration configuration, int formulaIndex) { ModelTraverser = new ModelTraverser(createModel, configuration, 0, false); ModelTraverser.Context.TraversalParameters.TransitionActions.Add(() => new InvariantViolationByIndexAction(formulaIndex)); }
public AnalysisModelFactoryTests() { definition = CircuitGenerator.GetCircuitWithBasicDevices(); creator = new AnalysisModelCreator(); }