private static void WriteStatusAndCommuncationNext(SMVModel nuSMV)
{
string op = "";
//write instances
foreach (var module in nuSMV.Modules)
{
Instance instance = module.Instance;
//write parent instances...
if (instance is ParentInstance)
{
op += TVariables.WriteStatusNextWithInstance(module, instance);
op += TVariables.WriteParentDivisionVariableNext(module, instance as ParentInstance);
}
else if (instance is ChildInstance)
{
//Print status rules of each child instance
op += TVariables.WriteChildStatusNext(module, instance as ChildInstance);
op += TVariables.WriteChildDivisionVariablesNext(instance as ChildInstance);
}
foreach (var variable in module.Variables)
{
if (variable.Behaviour == VariableBehaviour.COMMUNICATION)
{
op += TVariables.CommunicationVariableNext(module, instance, variable);
}
}
}
Writer.WriteLine(op);
}
public static void Translate(KpCore.KpModel kpModel, Experiment kpx, string outFileName)
{
KPsystem kpSystem = kpModel.KPsystem;
KpMetaModel kpMetaModel = new KpMetaModel(kpSystem);
try
{
//Translate KP model to SMV model
SMVModel nuSMV = BNuSMV.buildModel(kpSystem);
//SMVModels are loaded, in first run write variable to XML files, in 2nd run these values can be read.
foreach (var module in nuSMV.Modules)
{
BVariables.writeBounds2XML(module);
}
//Generate SMV file
if (nuSMV != null)
{
PrintNuSMV(nuSMV, kpMetaModel, kpx, outFileName);
}
else
{
throw new Exception("NuSMV translation failed.");
}
}
catch (Exception ex)
{
Console.WriteLine("Exception occurred during NuSMV translation.");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
throw ex;
}
}
private static void PrintNuSMV(SMVModel nuSMV, KpMetaModel kpMetaModel, Experiment kpx, string outFileName)
{
//instantiate output file, otherwise to console
Writer.FileName = outFileName;
Writer.CleanFile(outFileName);
bool firstModule = true;
foreach (var module in nuSMV.Modules)
{
if (!firstModule)
{
TUtil.AddDashedComment(module.Type.ToUpper());
}
WriteModule(module);
WriteVariables(module);
WriteINVAR(module);
WriteInit(module);
if (!module.HasDivisionRule && module.HasDissolutionRule)
{
WriteStatusNext(module);
}
WriteNext(module);
firstModule = false;
}
WriteMain(nuSMV);
WriteStatusAndCommuncationNext(nuSMV);
WriteProperties(kpx, kpMetaModel);
}
/// <summary>
/// Get list of all connected instances to @param kpInstance as the list of SMV instances.
/// </summary>
/// <param name="nuSMV"></param>
/// <param name="kPsystem"></param>
/// <param name="kpInstance"></param>
/// <returns></returns>
public static List <Instance> getInstanceConnections(SMVModel nuSMV, KPsystem kPsystem, MInstance kpInstance)
{
List <Instance> smvInstances = new List <Instance>();
foreach (var connected in kpInstance.Connections)
{
MType targetType = findTargetTypeOfInstance(kPsystem, connected);
Module targetModule = nuSMV.getModule(targetType, connected);
Instance smvInstance = targetModule.Instance;
if (smvInstance != null)
{
// if connection is not exist then add it
if (!smvInstances.Exists(item => item.Name == smvInstance.Name))
{
smvInstances.Add(smvInstance);
}
}
else
{
throw new Exception("Corresponding SMV instance of " + connected.Name + " not found!");
}
}
return(smvInstances);
}
private static Case buildSynchNext(SMVModel nuSMV)
{
Case newCase = new Case();
CaseLine caseLine = new CaseLine();
foreach (var module in nuSMV.Modules)
{
string next = SMVKeys.NEXT + "(" + module.Instance.Name + "." + CustomVariables.TURN + ")";
string ready = TurnStates.READY;
caseLine.Rule.AppendBoolExpression(new BoolExp(next, NuSMV.RelationalOperator.EQUAL, ready), BinaryOperator.AND);
if (module.HasDivisionRule)
{
foreach (var childIntstance in module.ChildInstances)
{
next = SMVKeys.NEXT + "(" + childIntstance.Name + "." + CustomVariables.TURN + ")";
ready = TurnStates.READY;
caseLine.Rule.AppendBoolExpression(new BoolExp(next, NuSMV.RelationalOperator.EQUAL, ready), BinaryOperator.AND);
}
}
}
caseLine.Result = new Expression(SynchStates.EXCHANGE);
newCase.CaseLines.Add(caseLine);
newCase.CaseLines.Add(BRulesStandardVar.trueCaseLine(SynchStates.BUSY));
return(newCase);
}
/// <summary>
/// For each MInstance (KP instance) generate a SMV instance.
/// </summary>
/// <param name="nuSMV"></param>
/// <param name="module"></param>
/// <param name="type"></param>
/// <param name="kpInstance"></param>
public static void generateSMVInstances(SMVModel nuSMV, Module module, MType type, MInstance kpInstance)
{
Instance smvInstance = null;
//If module has division rule then being child or parent becomes matter, otherwise they are default SMV instances
if (module.HasDivisionRule)
{
//Define module behaviour based on whether the instance is a parent or a child
//Status parameter, parents start in ACTIVE; child instances start in NONEXIST state
ParameterVar statusParam = new ParameterVar();
//A Child instance
if (kpInstance is KPChildInstance)
{
// generate SMV Child Instance
smvInstance = new ChildInstance();
smvInstance.DivisionType = DIVISIONTYPE.CHILD;
//Start Status parameter in NONEXISTS state
statusParam.Name = CustomVariables.STATUS;
statusParam.Behaviour = VariableBehaviour.CUSTOM;
statusParam.Init = StatusStates.NONEXIST;
smvInstance.Parameters.Add(statusParam);
//add this instance to its parent children
crossReferChild2ParentInstance(nuSMV, type, kpInstance, smvInstance as ChildInstance);
}
// A Parent instance
else
{
// generate SMV Parent Instance
smvInstance = new ParentInstance();
smvInstance.DivisionType = DIVISIONTYPE.PARENT;
//Start Status parameter in Active state
statusParam.Name = CustomVariables.STATUS;
statusParam.Behaviour = VariableBehaviour.CUSTOM;
statusParam.Init = StatusStates.ACTIVE;
smvInstance.Parameters.Add(statusParam);
}
//set parameter to module as well.
module.Parameters.Add(statusParam);
}
//Default instance
else
{
smvInstance = new Instance();
smvInstance.DivisionType = DIVISIONTYPE.NODIVISION;
}
smvInstance.Name = kpInstance.Name;
//join custom parameters, e.g., status, with model parameters
smvInstance.Parameters.UnionWith(getInstanceParameters(module, type, kpInstance));
//cross reference module and its instance
smvInstance.Module = module;
module.Instance = smvInstance;
}
private static void assignLastCasesToNext(SMVModel nuSMV)
{
foreach (var module in nuSMV.Modules)
{
BRulesStandardVar.assignLastCasesToNext(module);
if (module.HasDivisionRule)
{
BRulesStandardVar.assignLastCasesToDivisionVars(module);
}
}
}
private static Case buildPStepNext(SMVModel nuSMV)
{
Case newCase = new Case();
CaseLine caseLine = new CaseLine();
//_sync = _EXCH
ICondition synchIsExch = new BoolExp(CustomVariables.SYNCH, NuSMV.RelationalOperator.EQUAL, SynchStates.EXCHANGE);
caseLine.Rule.Condition = synchIsExch;
caseLine.Result = new Expression(Truth.TRUE);
newCase.CaseLines.Add(caseLine);
newCase.CaseLines.Add(BRulesStandardVar.trueCaseLine(Truth.FALSE));
return(newCase);
}
private static void buildMain(SMVModel nuSMV)
{
MainModule main = new MainModule();
//build next case for synch variable
Case synchNext = buildSynchNext(nuSMV);
main.Synch.Next.CaseStatement = synchNext;
//build next case for PStep variable
Case pStepNext = buildPStepNext(nuSMV);
main.PStep.Next.CaseStatement = pStepNext;
nuSMV.MainModule = main;
}
/// <summary>
/// Cross reference child instance to its parent, and vice versa
/// </summary>
/// <param name="type"></param>
/// <param name="kpInstance"></param>
private static void crossReferChild2ParentInstance(SMVModel nuSMV, MType type, MInstance kpInstance, ChildInstance childSMVInstance)
{
//Access its parent KP instance
MInstance parentKPInstance = (kpInstance as KPChildInstance).ParentKPInstance;
ParentInstance parentSMVInstance = getSMVInstance(nuSMV, parentKPInstance);
if (childSMVInstance.ParentInstance == null)
{
childSMVInstance.ParentInstance = parentSMVInstance;
}
else
{
throw new Exception("Error: Cross reference error with child and parent SMV instance...");
}
if (!parentSMVInstance.ChildInstances.Contains(childSMVInstance))
{
parentSMVInstance.ChildInstances.Add(childSMVInstance);
}
}
/// <summary>
/// Return SMV counterpart of given KP instance
/// </summary>
/// <param name="nuSMV"></param>
/// <param name="parentKPInstance"></param>
/// <returns></returns>
private static ParentInstance getSMVInstance(SMVModel nuSMV, MInstance parentKPInstance)
{
ParentInstance parentSMVInstance = null;
foreach (Module module in nuSMV.Modules)
{
if (module.Instance.Name.Equals(parentKPInstance.Name))
{
if (module.Instance is ParentInstance)
{
parentSMVInstance = (ParentInstance)module.Instance;
break;
}
}
}
if (parentSMVInstance == null)
{
throw new Exception("Error: KPInstance counterpart not found in any SMV modules!");
}
return(parentSMVInstance);
}
/// <summary>
/// Build variables comes from KP model.
/// </summary>
/// <param name="nuSMV"></param>
/// <param name="module"></param>
/// <param name="kpType"></param>
public static void buildStandardVariables(SMVModel nuSMV, NuSMV.Module module, KPsystem kpSystem, KpCore.MType kpType)
{
ExecutionStrategy eS = kpType.ExecutionStrategy;
int strategyIndex = 0;
//First get variables from current type
while (eS != null)
{
foreach (var rule in eS.Rules)
{
//check if it is has guards, then create its variables.
if (rule.IsGuarded)
{
buildGuardVariable(kpSystem, kpType, module, strategyIndex, rule);
}
if (rule.Type == RuleType.MULTISET_REWRITING)
{
buildReWritingVariables(kpSystem, kpType, module, strategyIndex, rule);
}
else if (rule.Type == RuleType.REWRITE_COMMUNICATION)
{
buildCommunicationVariables(nuSMV, module, kpSystem, kpType, strategyIndex, rule);
}
else if (rule.Type == RuleType.MEMBRANE_DIVISION)
{
buildDivisionVariables(module, kpSystem, kpType, strategyIndex, rule);
}
else if (rule.Type == RuleType.MEMBRANE_DISSOLUTION)
{
buildDissolutionVariables(kpSystem, kpType, module, strategyIndex, rule);
}
}
strategyIndex++;
eS = eS.Next;
}
}
private static void WriteMain(SMVModel nuSMV)
{
TUtil.AddDashedComment("MAIN");
string op = SMVKeys.MODULE + " " + SMVKeys.MAIN + "\n";
op += SMVKeys.VAR + "\n";
//write synch,and PStep vars at first.
op += TVariables.VariableDefinition(nuSMV.MainModule.Synch);
op += TVariables.VariableDefinition(nuSMV.MainModule.PStep);
//write instances
foreach (var module in nuSMV.Modules)
{
//parent instance
op += TVariables.Instances(module.Instance);
//if exists, then child instances
if (module.HasDivisionRule)
{
foreach (var childInstance in module.ChildInstances)
{
op += TVariables.Instances(childInstance);
}
}
}
op += SMVKeys.ASSIGN + "\n";
//write init of synch and PStep vars
op += TVariables.InitVariable(nuSMV.MainModule.Synch);
op += TVariables.InitVariable(nuSMV.MainModule.PStep);
//write next of synch and PStep vars
op += TVariables.VariableNext(nuSMV.MainModule.Synch);
op += TVariables.VariableNext(nuSMV.MainModule.PStep);
Writer.WriteLine(op);
}
public static SMVModel buildModel(KPsystem param_kpSystem)
{
kpSystem = param_kpSystem;
if (kpSystem != null)
{
//set an id to each rules
prepareKpSystem(kpSystem);
nuSMV = new SMVModel();
try
{
//If there are division rules, generate child instances as kPInstance
foreach (var kpType in kpSystem.Types)
{
if (kpTypeHasDivisionRule(kpType))
{
List <KPChildInstance> kpChildInstances = BDivisionInstances.generateKPChildInstances(kpType);
if (kpChildInstances != null)
{
kpType.Instances.AddRange(kpChildInstances);
}
}
}
//Generate a module for each kPInstance, including child instances(if division rule exist)
foreach (var kpType in kpSystem.Types)
{
foreach (MInstance kpInstance in kpType.Instances)
{
Module module = new Module();
prepareSMVModule(module, kpType, kpInstance);
nuSMV.Modules.Add(module);
}
}
foreach (var kpType in kpSystem.Types)
{
foreach (MInstance kpInstance in kpType.Instances)
{
buildInstanceConnections(kpType, kpInstance);
}
}
foreach (var kpType in kpSystem.Types)
{
foreach (MInstance kpInstance in kpType.Instances)
{
Module module = nuSMV.getModule(kpType, kpInstance);
BVariables.generateCustomVariables(kpSystem, kpType, module);
}
}
foreach (var kpType in kpSystem.Types)
{
foreach (MInstance kpInstance in kpType.Instances)
{
buildModule(kpType, kpInstance);
}
}
if (nuSMV != null)
{
foreach (var kpType in kpSystem.Types)
{
foreach (MInstance kpInstance in kpType.Instances)
{
Module module = nuSMV.getModule(kpType, kpInstance);
if (module.HasDivisionRule)
{
BDivisionInstances.generateDivisionRules(kpType, kpInstance, module);
}
}
}
}
//assign cases for synch variable of main module.
buildMain(nuSMV);
//finalize model, add caseLast caselines, do modifications, sorting etc.
assignLastCasesToNext(nuSMV);
}
catch (Exception ex)
{
throw ex;
}
}
return(nuSMV);
}
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);
}
}
}
}
}
public static void buildVariables(KPsystem kpSystem, SMVModel nuSMV, NuSMV.Module module, KpCore.MType kpType)
{
// variables comes from KP model.
buildStandardVariables(nuSMV, module, kpSystem, kpType);
}
