Skip to main content
Jump to: navigation, search

VIATRA2/Frequently Asked Questions

Revision as of 08:09, 19 June 2008 by (Talk | contribs) (Patterns and pattern language)


What is VIATRA2?

VIATRA2 is a model transformation tool integrated into Eclipse. TODO

Is it available for free?

Yes. VIATRA2 is licensed under the Eclipse Public License v1.0.

How do I obtain Viatra2?

See VIATRA2 Installation.

How do I give feedback (bug reports, improvement ideas, experiences, observations)?

There are multiple possibilities:

VTML metamodeling


What are VPM/VTML relation multiplicities and how can I use them?

In the case of VPM/VTML, relation multiplicites are only markers, which means that the VIATRA modelspace does not enforce their validity but only reports if they do not hold. The reason for this is that (temporarily) inconsistent states must be allowed in order to allow model manipulation (either by the user or by a transformation).

The following relation multiplicities can be defined:

  • one_to_one: 1-1 relaction, every source element can reference at most one target element, and the same in the reverse
  • one_to_many: 1-*, every source element can reference an arbitrary number of target elements, but each target can reference at most one source
  • many_to_one: *-1, every source element can reference at most one target element, but each target can reference an arbitrary number of source elements
  • many_to_many: *-*, every source can reference an arbitrary number of targets and vice-versa

An example:

/* a valid model configuration */

Patterns and pattern language

What does the warning "Target end of Relation cannot be resolved locally" mean?

Such a warning means that your pattern definition does not contain a type constraint for the target end of a relation:

pattern dangerous(A,B) =

You get the warning because such patterns are dangerous in the sense that you can get run-time errors if you pass incorrect parameters to this pattern (e.g. a simple string constrant instead of a model element). Therefore, it is strongly recommended to include a type constraint for every variable that appears in the pattern:

pattern dangerous(A,B) =
  OtherType(B); // <-- correction

This is also necessary for the correct operation of the incremental pattern matching engine.

Can patterns (or a single pattern) reference each other recursively?

Yes. However, the recursion should be well-founded. In certain cases, pattern systems that are not well-founded (but have a sensible fixpoint) are also acceptable, but ensuring their correct behaviour is is the responsibility of the pattern engineer.

Can patterns and gtrules be referenced from other VTCL machines?

Yes. The fully qualified name of the pattern/gtrule should be used instead of the short name. The same applies for VTCL rules.



namespace mydomain.mysubdomain;
machine mymachine {
pattern mypattern(X) = {
rule myrule(in X) = ...


machine myothermachine {
pattern composite(A) = {
      find mydomain.mysubdomain.mymachine.mypattern(A);
rule somerule(in C) = seq{
      call mydomain.mysubdomain.mymachine.myrule(C);
      forall A in C with find mydomain.mysubdomain.mymachine.mypattern(A) do ...

The pattern matcher seems to discard some occurrences of my patterns. Why?

VTCL has injective pattern matching semantics; in other words, pattern occurrences have to be isomorphic to the pattern graph. The practical implication is that no two pattern variables in the same pattern body can take the same value; such occurrences will be rejected. Patterns should be designed with this important phenomenon in mind.

The only exception is explicit variable assignment (e.g. A=B). The relaxing effect of variable assignment also applies indirectly; the assignment can be asserted in a separate pattern called using the find keyword.


 pattern fullsiblings(X, Y) = {
      person.parent(PX1, X, Parent1);
      person.parent(PX2, X, Parent2);
      person.parent(PY1, Y, Parent1);
      person.parent(PY2, Y, Parent2);
As Parent1 and Parent2 are not allowed to coincide due to injectivity, X and Y need two separate common parents. Therefore this pattern does not match half-siblings. Injectivity also keeps X and Y separate, so a single person with two parents does not fit the pattern either.

VTCL transformations

How do I invoke graph transformation rules in VTCL?

The source excerpt below shows a simple example for invoking a graph transformation rule. Note that unbound variables, which are determined by pattern matching, are marked as out variables in the gtrule definition.

gtrule myGTRule(in A, out B) =
rule xfromObject(in A) =
  forall B with apply myGTRule(A,B) do skip;

Graphical user interface and usage


How to create transformations and load them into VIATRA2?

How to run a transformation?

How can I edit my model elements in the model space?

What hotkeys can be used in the VTCL editor?

How to export transformations as EMF models?

How to import models into the VIATRA2 model space?

How to export models from the VIATRA2 model space into my native format?

How can I create domain-specific languages in VIATRA2?

How can I customize the VIATRA treeview-based model space editor?

Sensoria CASE Tool




Back to the top