public ResponsibilityNode(ResponsibilityNode parent)
{
if (parent != null)
{
this.parent = parent;
this.parent.children.Add(this);
}
this.children = new List <ResponsibilityNode> ();
Responsibility = new Dictionary <Agent, IList <Goal> >();
}
private static void RecursiveGetResponsibilities(ResponsibilityNode current, Goal goal)
{
var hasAlternatives = (goal.Refinements().Count() + goal.AgentAssignments().Count()) > 1;
if (hasAlternatives)
{
foreach (var refinement in goal.Refinements())
{
var newNode = new ResponsibilityNode(current);
foreach (var childGoal in refinement.SubGoals())
{
RecursiveGetResponsibilities(newNode, childGoal);
}
}
foreach (var assignment in goal.AgentAssignments())
{
foreach (var agent in assignment.Agents())
{
var newNode = new ResponsibilityNode(current);
if (!newNode.Responsibility.ContainsKey(agent))
{
newNode.Responsibility.Add(agent, new List <Goal> ());
}
newNode.Responsibility[agent].Add(goal);
}
}
}
else
{
foreach (var refinement in goal.Refinements())
{
foreach (var childGoal in refinement.SubGoals())
{
RecursiveGetResponsibilities(current, childGoal);
}
}
foreach (var assignment in goal.AgentAssignments())
{
foreach (var agent in assignment.Agents())
{
if (!current.Responsibility.ContainsKey(agent))
{
current.Responsibility.Add(agent, new List <Goal> ());
}
current.Responsibility[agent].Add(goal);
}
}
}
}
public static ResponsibilityNode GetResponsibilities(this KAOSModel model)
{
var node = new ResponsibilityNode(null);
foreach (var rootGoal in model.RootGoals())
{
RecursiveGetResponsibilities(node, rootGoal);
}
Factorize(node);
Collapse(node);
return(node);
}
private static void Collapse(ResponsibilityNode r)
{
if (r.Responsibility.Count() == 0 && r.parent != null)
{
r.parent.children.Remove(r);
foreach (var r2 in r.children)
{
r2.parent = r.parent;
r.parent.children.Add(r2);
}
}
foreach (var r2 in r.children.ToArray())
{
Collapse(r2);
}
}
private static void Factorize(ResponsibilityNode node)
{
foreach (var childResponsibility in node.children)
{
foreach (var kv in childResponsibility.Responsibility.ToArray())
{
var agent = kv.Key;
var goals = kv.Value;
// For each goal assigned to an agent
foreach (var goal in goals.ToArray())
{
if (node.children.All(x => x.Responsibility.ContainsKey(agent) && x.Responsibility[agent].Contains(goal)))
{
if (!node.Responsibility.ContainsKey(agent))
{
node.Responsibility.Add(agent, new List <Goal> ());
}
node.Responsibility[agent].Add(goal);
foreach (var c in node.children)
{
c.Responsibility[agent].Remove(goal);
if (c.Responsibility[agent].Count == 0)
{
c.Responsibility.Remove(agent);
}
}
}
}
}
}
// if two alternatives are the same, remove one of the two
for (int i = 0; i < node.children.Count; i++)
{
var t = node.children[i];
for (int j = i + 1; j < node.children.Count; j++)
{
var t2 = node.children[j];
var eq = true;
// All elements in t are in t2
foreach (var agent in t.Responsibility.Keys)
{
if (t2.Responsibility.ContainsKey(agent))
{
foreach (var g in t.Responsibility[agent])
{
if (!t2.Responsibility[agent].Contains(g))
{
eq = false;
}
}
}
else
{
eq = false;
}
}
// All elements in t2 are in t
foreach (var agent in t2.Responsibility.Keys)
{
if (t.Responsibility.ContainsKey(agent))
{
foreach (var g in t2.Responsibility[agent])
{
if (!t.Responsibility[agent].Contains(g))
{
eq = false;
}
}
}
else
{
eq = false;
}
}
if (eq)
{
node.children.Remove(t2);
}
}
}
}