public void Render(KAOSModel model)
{
//var goalsInRefinements = model.GoalRefinements ().SelectMany (x => x.SubGoals ().Union (new[] {
// x.ParentGoal ()
//})).Distinct ();
foreach (var g in model.Goals())
{
Render(g);
}
foreach (var d in model.GoalRefinements().SelectMany(x => x.DomainProperties()).Distinct())
{
Render(d);
}
foreach (var d in model.GoalRefinements().SelectMany(x => x.DomainHypotheses()).Distinct())
{
Render(d);
}
foreach (var r in model.GoalRefinements())
{
Render(r);
}
foreach (var r in model.GoalAgentAssignments())
{
Render(r, true);
}
}
public KAOSModel Parse(string input, string filename)
{
KAOSModel model = new KAOSModel();
GoalModelParser _parser = new GoalModelParser();
Uri RelativePath = null;
if (!string.IsNullOrEmpty(filename))
{
RelativePath = new Uri(Path.GetFullPath(Path.GetDirectoryName(filename) + "/"));
}
FirstStageBuilder FSB = new FirstStageBuilder(model, RelativePath);
FormulaBuilder FB = new FormulaBuilder(model, RelativePath);
SecondStageBuilder SSB = new SecondStageBuilder(model, RelativePath);
ThirdStageBuilder TSB = new ThirdStageBuilder(model, FB, RelativePath);
var elements = _parser.Parse(input, filename) as ParsedElements;
FSB.BuildElementWithKeys(elements);
SSB.BuildElement(elements);
TSB.BuildElement(elements);
return(model);
}
public ModelMonitor(KAOSModel model, IEnumerable <Goal> roots)
{
obstacleMonitors = new Dictionary <string, ObstacleMonitor>();
_model_running = model;
_roots = new HashSet <Goal>(roots);
Initialize();
}
public SingleValueCriticalObstacles(KAOSModel model, Goal root) : base(model, root)
{
_propagator = new BDDBasedPropagator(model);
_propagator.PreBuildObstructionSet(root);
rsr = root.RDS;
}
public GoalRelaxedTo(KAOSModel model, string goalIdentifier, string obstacleIdentifier, Formula formula)
: base(model)
{
GoalIdentifier = goalIdentifier;
ObstacleIdentifier = obstacleIdentifier;
Formula = formula;
}
public override void Handle(Relation element, ParsedLinkAttribute attribute, KAOSModel model)
{
Entity entity;
if (attribute.Target is IdentifierExpression)
{
string id = ((IdentifierExpression)attribute.Target).Value;
if ((entity = model.entityRepository.GetEntity(id)) == null)
{
entity = new Entity(model, id)
{
Implicit = true
};
model.entityRepository.Add(entity);
}
element.Links.Add(new Link(model)
{
Target = entity, Multiplicity = attribute.Multiplicity
});
}
else
{
throw new UnsupportedValue(element, attribute, attribute.Target);
}
}
public RandomModelGenerator(RandomModelOptions options)
{
this._options = options;
_model = new KAOSModel();
_random = new Random();
_faker = new Faker();
}
public ThirdStageBuilder(KAOSModel model,
FormulaBuilder fb,
Uri relativePath)
: base(model, relativePath)
{
declareBuilders.Add(new AgentDeclareBuilder());
declareBuilders.Add(new AssociationDeclareBuilder());
declareBuilders.Add(new CalibrationDeclareBuilder());
declareBuilders.Add(new DomainHypothesisDeclareBuilder());
declareBuilders.Add(new DomainPropertyDeclareBuilder());
declareBuilders.Add(new EntityDeclareBuilder());
declareBuilders.Add(new ExpertDeclareBuilder());
declareBuilders.Add(new GoalDeclareBuilder());
declareBuilders.Add(new SoftGoalDeclareBuilder());
declareBuilders.Add(new TypeDeclareBuilder());
declareBuilders.Add(new ObstacleDeclareBuilder());
declareBuilders.Add(new PredicateDeclareBuilder());
declareBuilders.Add(new ContextDeclareBuilder());
attributeBuilders.Add(new ArgumentAttributeBuilder());
attributeBuilders.Add(new FormalSpecAttributeBuilder(fb));
attributeBuilders.Add(new ProvidedNotAttributeBuilder(fb));
attributeBuilders.Add(new ProvidedAttributeBuilder(fb));
attributeBuilders.Add(new RelaxedToAttributeBuilder(fb));
}
public PatternBasedPropagator(KAOSModel model)
{
_model = model;
goalCache = new Dictionary <Goal, ISatisfactionRate>();
obstacleCache = new Dictionary <Obstacle, ISatisfactionRate>();
}
public override void Handle(Goal element, ParsedExceptAttribute attribute, KAOSModel model)
{
var exception = new GoalException(model);
exception.AnchorGoalIdentifier = element.Identifier;
exception.ResolvingGoalIdentifier = attribute.CountermeasureIdentifier;
exception.ResolvedObstacleIdentifier = attribute.ObstacleIdentifier;
if (!model.goalRepository.GoalExists(attribute.CountermeasureIdentifier))
{
model.Add(new Goal(model)
{
Identifier = attribute.CountermeasureIdentifier,
Implicit = true
});
}
if (!model.obstacleRepository.ObstacleExists(attribute.ObstacleIdentifier))
{
model.Add(new Obstacle(model)
{
Identifier = attribute.ObstacleIdentifier,
Implicit = true
});
}
model.Add(exception);
}
public void Render(Goal g, KAOSModel model)
{
Render(g);
foreach (var e in g.Replacements())
{
Render(e.AnchorGoal());
Render(e);
}
foreach (var r in g.ParentRefinements().Union(g.Refinements()))
{
if (!shapes.ContainsKey(r.ParentGoalIdentifier))
{
Render(r.ParentGoal());
}
foreach (var sg in r.SubGoals())
{
if (!shapes.ContainsKey(sg.Identifier))
{
Render(sg);
}
}
Render(r);
}
}
public NaiveCountermeasureSelectionOptimizerWithUncertainty(KAOSModel model, double threshold)
{
_model = model;
stats = new OptimizationStatistics();
integrator = new SoftResolutionIntegrator(model);
this.threshold = threshold;
}
public GoalProvidedNot(KAOSModel model, string goalIdentifier, string obstacleIdentifier, Formula formula)
: base(model)
{
GoalIdentifier = goalIdentifier;
ObstacleIdentifier = obstacleIdentifier;
Formula = formula;
}
public CriticalUncertainObstacles(KAOSModel model, Goal root) : base(model, root)
{
_propagator = new BDDBasedUncertaintyPropagator(model, n_samples);
_propagator.PreBuildObstructionSet(root);
rsr = root.RDS;
}
public void Render(KAOSModel model)
{
var goals = model.Exceptions().SelectMany(x => new[] { x.AnchorGoal(), x.ResolvingGoal() });
goals = goals.Union(model.ObstacleAssumptions().SelectMany(x => new[] { x.Anchor() })).Distinct();
var obstacles = model.ObstacleAssumptions().SelectMany(x => new[] { x.Obstacle() });
foreach (var g in goals)
{
Render(g);
}
foreach (var o in obstacles)
{
Render(o);
}
foreach (var e in model.Exceptions())
{
Render(e);
}
foreach (var e in model.ObstacleAssumptions())
{
Render(e);
}
}
public override void Handle(Goal element, ParsedReplacesAttribute attribute, KAOSModel model)
{
var goalReplacement = new GoalReplacement(model);
goalReplacement.AnchorGoalIdentifier = element.Identifier;
goalReplacement.ResolvingGoalIdentifier = attribute.ReplacedGoalIdentifier;
goalReplacement.ResolvedObstacleIdentifier = attribute.ObstacleIdentifier;
model.Add(goalReplacement);
}
public void TestParsedDeclareGoal()
{
var model = new KAOSModel();
var path = new Uri("/tmp/fake");
var builder = new FirstStageBuilder(model, path);
builder.BuildDeclare(new ParsedGoal("my-goal"));
model.Goals(x => x.Identifier == "my-goal").ShallBeSingle();
}
/// <summary>
/// Creates a new monitoring infrastructure for the specified formulas.
/// The projection is used to compute the hash of the observed states.
/// </summary>
/// <param name="elements">The goals to monitor.</param>
/// <param name="storage">The storage.</param>
/// <param name="defaultProjection">Projection.</param>
public KAOSCoreElementMonitor(KAOSModel model,
KAOSCoreElement elements,
TimeSpan monitoringDelay)
{
Ready = false;
this.model = model;
this.MonitoringDelay = monitoringDelay;
}
public void Render(Goal g, KAOSModel model)
{
Render(g);
foreach (var e in g.Provided())
{
Render(e.Obstacle());
Render(e);
}
}
public void TestFailWhenParsedDeclareUnknow()
{
var model = new KAOSModel();
var path = new Uri("/tmp/fake");
var builder = new FirstStageBuilder(model, path);
Assert.Catch(() => {
builder.BuildDeclare(new UnknownParsedDeclare("unknown"));
});
}
public void Render(Obstacle o, KAOSModel model)
{
Render(o);
foreach (var obstruction in o.model.Obstructions().Where(x => x.ObstacleIdentifier == o.Identifier))
{
Render(obstruction.ObstructedGoal());
Render(obstruction);
}
RenderRefinement(o);
}
public override void BuildDeclare(ParsedDeclare parsedElement, KAOSModel model)
{
Entity g = model.entityRepository.GetEntity(parsedElement.Identifier);
if (g == null)
{
g = new Entity(model, parsedElement.Identifier);
model.entityRepository.Add(g);
} else if (!parsedElement.Override) {
throw new BuilderException("Cannot declare twice the same element. Use override instead.", parsedElement);
}
}
public GoalMonitor(Goal goal,
KAOSModel model,
HashSet <string> projection,
IStateInformationStorage storage,
TimeSpan monitoringDelay) : base(model, goal, monitoringDelay)
{
this.goal = goal;
this.storage = storage;
Initialize();
}
public ObstacleMonitor(Obstacle obstacle,
KAOSModel model,
IStateInformationStorage storage,
TimeSpan monitoringDelay) : base(model, obstacle, monitoringDelay)
{
this.storage = storage;
this.obstacle = obstacle;
SetProjection();
Initialize();
}
public void Render(Goal g, KAOSModel model)
{
Render(g);
// Exceptions
foreach (var e in g.Exceptions())
{
if (!shapes.ContainsKey(e.ResolvingGoalIdentifier))
{
Render(e.ResolvingGoal());
}
Render(e);
}
// Replacements
foreach (var e in g.Replacements())
{
if (!shapes.ContainsKey(e.AnchorGoalIdentifier))
{
Render(e.AnchorGoal());
}
Render(e);
}
// Provided
foreach (var e in g.Provided())
{
if (!shapes.ContainsKey(e.ResolvedObstacleIdentifier))
{
Render(e.Obstacle());
}
Render(e);
}
// Context refinements
/*
* foreach (var r in g.ParentRefinements ().Union (g.Refinements ())) {
* if (!shapes.ContainsKey (r.ParentGoalIdentifier)) {
* Render (r.ParentGoal ());
* }
*
* foreach (var sg in r.SubGoals ()) {
* if (!shapes.ContainsKey (sg.Identifier)) {
* Render (sg);
* }
* }
*
* Render (r);
* }
*/
}
public void Render(KAOSModel model)
{
//var goalsInRefinements = model.GoalRefinements ().SelectMany (x => x.SubGoals ().Union (new[] {
// x.ParentGoal ()
//})).Distinct ();
foreach (var g in model.Goals())
{
Render(g);
}
foreach (var d in model.GoalRefinements().SelectMany(x => x.DomainProperties()).Distinct())
{
Render(d);
}
foreach (var r in model.GoalRefinements())
{
Render(r);
}
foreach (var o in model.Obstacles())
{
Render(o);
}
foreach (var o in model.ObstacleRefinements())
{
Render(o);
}
foreach (var o in model.Obstructions())
{
Render(o);
}
foreach (var o in model.Resolutions())
{
Render(o);
}
foreach (var r in model.GoalAgentAssignments())
{
Render(r, true);
}
foreach (var o in model.Resolutions())
{
RenderAnchorArrow(o);
}
}
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);
}
public override void BuildDeclare(ParsedDeclare parsedElement, KAOSModel model)
{
Obstacle g = model.obstacleRepository.GetObstacle(parsedElement.Identifier);
if (g == null)
{
g = new Obstacle(model, parsedElement.Identifier);
model.obstacleRepository.Add(g);
}
else if (!parsedElement.Override)
{
throw new BuilderException("Cannot declare twice the same element '" + parsedElement.Identifier + "'. Use override instead.", parsedElement);
}
}
public override void BuildDeclare(ParsedDeclare parsedElement, KAOSModel model)
{
Context context = model.modelMetadataRepository.GetContext(parsedElement.Identifier);
if (context == null)
{
context = new Context(model, parsedElement.Identifier);
model.modelMetadataRepository.Add(context);
}
else if (!parsedElement.Override)
{
throw new BuilderException("Cannot declare twice the same element. Use override instead.", parsedElement);
}
}
public static Document ExportModel(KAOSModel _model)
{
mapping = new Dictionary <Omnigraffle.Sheet, Dictionary <string, Omnigraffle.ShapedGraphic> >();
var document = new Omnigraffle.Document();
var canvas = new Omnigraffle.Sheet(1, string.Format("Model"));
var shapes = new Dictionary <string, IList <Graphic> >();
var u = new GoalModelGenerator(canvas, shapes);
u.Render(_model);
document.Canvas.Add(canvas);
var s2 = new Omnigraffle.Sheet(1, "Goal and Obstacle Model");
var u2 = new GoalAndObstacleModelGenerator(s2, new Dictionary <string, IList <Graphic> >());
u2.Render(_model);
document.Canvas.Add(s2);
int i = 0;
foreach (var o in _model.Obstructions().Select(x => x.Obstacle()))
{
i++;
var s = new Omnigraffle.Sheet(1, string.Format($"Obstacle diagram for '{o.FriendlyName}'"));
var u3 = new ObstacleDiagramGenerator(s, new Dictionary <string, IList <Graphic> >());
u3.Render(o, _model);
document.Canvas.Add(s);
}
i = 0;
foreach (var goalWithException in _model.Exceptions().Select(x => x.AnchorGoal())
.Union(_model.Replacements().Select(x => x.ResolvingGoal()))
.Union(_model.ObstacleAssumptions().Select(x => x.Anchor()))
.Distinct())
{
i++;
var s = new Omnigraffle.Sheet(1, string.Format($"Exception diagram for '{goalWithException.FriendlyName}'"));
var u3 = new ExceptionDiagramGenerator(s, new Dictionary <string, IList <Graphic> >());
u3.Render(goalWithException, _model);
document.Canvas.Add(s);
}
return(document);
}
