internal static void assignLastCasesToDivisionVars(Module module) { if (module.HasDivisionRule) { if (module.Instance is ChildInstance) { ChildInstance childInstance = (ChildInstance)module.Instance; // childInstance.DivisionStatus.Next.CaseStatement.CaseLines.Add(trueCaseLine(childInstance.DivisionStatus)); foreach (var variable in module.Variables) { if (variable.Behaviour == VariableBehaviour.DIVISION) { //Copy all rules of division variable which are added after division value calculation in BDivision name space. Variable divisionVar = (Variable)childInstance.DivisionVariables.First(item => item.Name.Equals(variable.Name)); if (variable is Variable) { foreach (var caseLine in (variable as Variable).Next.CaseStatement.CaseLines) { if (!BRulesComVar.ruleExist(divisionVar.Next, caseLine as CaseLine)) { divisionVar.Next.addCaseLine(caseLine); } } } } } } } }
/// <summary> /// Extract condition from KP Rule, add condition to the next of variable. Rule behaviour are writing rules. /// </summary> /// <param name="variable"></param> /// <param name="kpRule"></param> /// <param name="module"></param> /// <param name="strategyIndex"></param> internal static void addCaseLineToStandardVariable(Variable variable, KpCore.Rule kpRule, Module module, int strategyIndex) { //for each variable generate a case line CaseLine caseLine = new CaseLine(); caseLine.Result = getResultOfRuleFromKPRule(module, kpRule, variable); caseLine.Rule = extractStandardRuleFromKPRule(kpRule, module, strategyIndex); caseLine.Rule.ID = kpRule.Id; //if result is division or dissolution it will be null if (caseLine.Result != null) { caseLine.Rule.AddBoolExpression(getBoundCondition(variable, caseLine.Result), BinaryOperator.AND); } else { throw new Exception("BRulesStandarVar, line 176"); // caseLine.Result = new Expression(variable.Name); } ICondition statusCondition = getTurnCondition(module, strategyIndex); ICondition sequenceCondition = getSequenceCondition(module, strategyIndex, kpRule.Id); CompoundBoolExpression statusAndTurn = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceCondition); caseLine.Rule.AddBoolExpression(statusAndTurn, BinaryOperator.AND); if (variable.Next != null) { if (!BRulesComVar.ruleExist(variable.Next, caseLine)) { variable.Next.addCaseLine(caseLine); } } }
private static CompoundBoolExpression getInstancedStatusAndSyncCondition(Module module) { ICondition status = null; if (module.HasDissolutionRule || module.HasDivisionRule) { status = BRulesComVar.getInstancedStatus(module, StatusStates.ACTIVE); } // this is non-instanced _sync = _EXCH BoolExp synchIsExch = new BoolExp(); synchIsExch.Left = new Expression(CustomVariables.SYNCH); synchIsExch.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL; synchIsExch.Right = new Expression(SynchStates.EXCHANGE); //(_sync = _EXCH) CompoundBoolExpression statusAndSync = new CompoundBoolExpression(status, BinaryOperator.AND, synchIsExch); return(statusAndSync); }
internal static void addRuleToStatusVariable(KpCore.Rule rule, NuSMV.Module module, int strategyIndex) { // ((main._status = _willDIVIDE) & (_sync = _BUSY)) : _willDIVIDE; ((main._status = _willDIVIDE) & (_sync = // _EXCH)) : _DIVIDED; if (module.HasDivisionRule) { CaseLine willDivideCaseLine = new CaseLine(); //((main._status = _willDIVIDE) & (_sync = _BUSY)) : _willDIVIDE; ICondition willDivide = BRulesStandardVar.getStatusCondition(module, StatusStates.WILLDIVIDE); ICondition syncBusy = new BoolExp(CustomVariables.SYNCH, NuSMV.RelationalOperator.EQUAL, SynchStates.BUSY); willDivideCaseLine.Rule.Condition = new CompoundBoolExpression(willDivide, BinaryOperator.AND, syncBusy); willDivideCaseLine.Result = new Expression(StatusStates.WILLDIVIDE); if (!BRulesComVar.ruleExist(module.Status.Next, willDivideCaseLine)) { module.Status.Next.addCaseLine(willDivideCaseLine); } // ((main._status = _willDIVIDE) & (_sync = _EXCH)) : _DIVIDED; CaseLine dividedCaseLine = new CaseLine(); ICondition syncExch = new BoolExp(CustomVariables.SYNCH, NuSMV.RelationalOperator.EQUAL, SynchStates.EXCHANGE); dividedCaseLine.Rule.Condition = new CompoundBoolExpression(willDivide, BinaryOperator.AND, syncExch); dividedCaseLine.Result = new Expression(StatusStates.DIVIDED); if (!BRulesComVar.ruleExist(module.Status.Next, dividedCaseLine)) { module.Status.Next.addCaseLine(dividedCaseLine); } } // ((main._status = _willDISSOLVE) & (_sync = _BUSY)) : _willDISSOLVE; ((main._status = _willDISSOLVE) & (_sync = // _EXCH)) : _DISSOLVED; if (module.HasDissolutionRule) { CaseLine caseLine2 = new CaseLine(); //status = willDissolve & (_sync = _BUSY) : willDissolve; ICondition willSolve = BRulesStandardVar.getStatusCondition(module, StatusStates.WILLDISSOLVE); ICondition syncBusy = new BoolExp(CustomVariables.SYNCH, NuSMV.RelationalOperator.EQUAL, SynchStates.BUSY); caseLine2.Rule.Condition = new CompoundBoolExpression(willSolve, BinaryOperator.AND, syncBusy); caseLine2.Result = new Expression(StatusStates.WILLDISSOLVE); if (!BRulesComVar.ruleExist(module.Status.Next, caseLine2)) { module.Status.Next.addCaseLine(caseLine2); } //((c1._status = _willDISSOLVE) & (_sync = _EXCH)) : _DISSOLVED; CaseLine caseLine3 = new CaseLine(); ICondition syncExch = new BoolExp(CustomVariables.SYNCH, NuSMV.RelationalOperator.EQUAL, SynchStates.EXCHANGE); caseLine3.Rule.Condition = new CompoundBoolExpression(willSolve, BinaryOperator.AND, syncExch); caseLine3.Result = new Expression(StatusStates.DISSOLVED); if (!BRulesComVar.ruleExist(module.Status.Next, caseLine3)) { module.Status.Next.addCaseLine(caseLine3); } } CaseLine caseLine = new CaseLine(); caseLine.Result = getResultOfStatusRuleFromKPRule(module, rule); caseLine.Rule = BRulesStandardVar.extractStandardRuleFromKPRule(rule, module, strategyIndex); caseLine.Rule.ID = rule.Id; //if module has division rule then, dissolve process happens inside instances. // ICondition statusCondition = BRulesStandardVar.getStatusCondition(module); No need status=Active condition anymore ICondition sequence = BRulesStandardVar.getSequenceCondition(module, strategyIndex, rule.Id); //CompoundBoolExpression compound = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequence); caseLine.Rule.AddBoolExpression(sequence, BinaryOperator.AND); //if the case line has not added yet if (!BRulesComVar.ruleExist(module.Status.Next, caseLine)) { module.Status.Next.addCaseLine(caseLine); } }
private static void buildCommunicationVariables(SMVModel nuSMV, NuSMV.Module module, KPsystem kpSystem, KpCore.MType type, int strategyIndex, KpCore.Rule rule) { RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule; string varName = ""; VariableOrigin origin = VariableOrigin.Original; bool isLeft = true; //regular left hand-side rules foreach (var leftHRule in rcr.Lhs) { varName = leftHRule.Key; isLeft = true; buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, varName, origin, isLeft); } //regular right hand-side rules foreach (var rigthHRule in rcr.Rhs) { varName = rigthHRule.Key; origin = VariableOrigin.Original; isLeft = false; //first generate original one, then its copy if (!module.isVariableExist(varName)) { buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, varName, origin, isLeft); } string copyVarName = varName + SMVPreFix.COPY; origin = VariableOrigin.Copy; buildReWritingVariable(kpSystem, type, module, strategyIndex, rule, copyVarName, origin, isLeft); } //Targeted rules foreach (var target in rcr.TargetRhs.Values) { TargetedMultiset targetMultiSet = (TargetedMultiset)target; InstanceIdentifier targetTypeIdentifier = (InstanceIdentifier)targetMultiSet.Target; MType targetType = null; foreach (var tempType in kpSystem.Types) { if (tempType.Name == targetTypeIdentifier.Value) { targetType = tempType; } } //for each connected instance of the target type, create a copy variable foreach object in the multiset foreach (var connectedInstance in module.Instance.ConnectedTo) { if (connectedInstance.Module.Type == targetType.Name) { Module targetModule = connectedInstance.Module; Multiset ms = targetMultiSet.Multiset; foreach (var obj in ms.Objects) { varName = obj; Variable targetVariable = new Variable(varName); string currentCpVarName = SMVPreFix.getConnectedCopyCommVarName(varName, targetModule); Variable currentCpVar = new Variable(currentCpVarName); //create original variable inside target module if (!targetModule.isVariableExist(varName)) { setBoundIntType(kpSystem, targetType, targetModule, targetVariable); targetVariable.Behaviour = VariableBehaviour.COMMUNICATION; targetVariable.Origin = VariableOrigin.OriginalCommVar; targetVariable.Init = setOrUpdateInit(targetModule, targetVariable); targetModule.Variables.Add(targetVariable); } else { //if variable is already in target module, then make sure, it is set as communication var. targetVariable = (Variable)targetModule.Variables.First(item => item.Name.Equals(varName)); targetVariable.Behaviour = VariableBehaviour.COMMUNICATION; targetVariable.Origin = VariableOrigin.OriginalCommVar; targetVariable.Init = setOrUpdateInit(targetModule, targetVariable); } //create a varName_InstanceName_TargetModule, variable (as copy) inside current module. if (!module.isVariableExist(currentCpVarName)) { Variable orginalVariable = (Variable)targetModule.getVariable(varName); currentCpVar.Type = orginalVariable.Type; currentCpVar.Behaviour = VariableBehaviour.REWRITING; currentCpVar.Origin = VariableOrigin.CopyOfCommVar; currentCpVar.Init = "0"; module.Variables.Add(currentCpVar); } else { //if variable exists then update the values. currentCpVar = (Variable)module.Variables.First(item => item.Name.Equals(currentCpVarName)); } //add result of rule to caseline BRulesComVar.addCaseLineToCurrentCopyCommVar(targetVariable, currentCpVar, rule, module, targetModule, strategyIndex); } } } } }