HMR language

The HMR language has been designed to textual human and machine redable representation of XTT2 models. The syntax of the HMR is a subset of Prolog syntax where a number of operators have been defined.

Each HMR file consists of the following parts:

  • [requied] Types definitions (predicate xtype),
  • [optional] Types groups definitions (predicate xtpgr),
  • [requied] Attributes definitions (predicate xattr),
  • [optional] Attributes groups definitions (predicate xatgr),
  • [requied]Definicje schematów (tabel) (predicate xschm),
  • [requied] Rules definitions (predicate xrule),
  • [optional] States definitions (predicate xstat).
  • [optional] Callbacks definitions (predicate xcall)

Each of predicates (besides xschm and xrule) is a Prolog list, which defines the properities of a XTT object.

In example, the definitions of type weekdays and an attribute day is as follows:

xtype [name: weekdays,
       base: symbolic,
       desc: 'A set of days of the week',
       domain: ['Monday'/1,'Tuesday'/2,'Wednesday'/3,'Thursday'/4,'Friday'/5,'Saturday'/6,'Sunday'/7],
       ordered: yes
xattr [name: day,
       abbrev: day,
       class: simple,
       type: weekdays,
       comm: in,
       callback: [ask_symbolic_GUI,[day]],
       desc: 'The current day'
xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T),
	 Params = [AttName|Domain],
	 term_to_atom(Params, AtomParams),


Compare the HMR file with XTT model:

  • HMR file:

  • XTT file:

Callbacks in HMR

Callbacks are the functions that are executed during the XTT tables evaluation in order to get a value or to present a value. The example of the callbacks execution results are showed in the picture below. In the cashpoint system, the callbacks are used for calling a enter PIN dialog as well as for displaying messages to the user.

There are two types of callbacks:

  • in - are executed before (or during) inference process in order to get attributes value.
  • out - are executed for values of attributes presentation, when the inference process is finished.

The type of a callback is determined by value of the attribute comm property.

HMR syntax provides a callback property of the XTT attribute that indicates which callback function should be called. The property has a list structure, where the first element is the name of the callback function and the second is a list of parameters.

xattr [name: day,
       abbrev: day,
       class: simple,
       type: day,
       comm: in,
       callback: [ask_console,[day]]

The above example defines an attribute day. The value of the property comm of this attribute is in what defines the type of the callback to be in. For this attribute the ask_console callback function will be called, which will get the value of the attribute day.

Callbacks and attributes

In HMR, callbacks are related to attributes. For each attribute two properties must be defined in order to use callbacks:

  • comm - defines when the callback is executed (possible values: in or out)
  • callback - the name and the list of parameters of the required callback.

HMR provides xcall predicate that allows for callback definition. The following example shows the JPL mechnism, which is used to create a callback written in Java.

xcall ask_symbolic_GUI : [AttName] >>> (jpl_new('skeleton.RequestInterface',[],T),
	 Params = [AttName|Domain],
	 term_to_atom(Params, AtomParams),

Programming languages

HeaRT supports the callbacks written in:

  • Prolog
  • XPCE
  • Java


Prolog-based callbacks are an ordinary Prolog predicates.

xcall ask_console : [AttName] >>> (write('Type value for attribute:  '),

In order to run inference process directly from HeaRT interpreter you must:

  • download the source code of HeaRT heart-m3.tar.gz,
  • run it by typing heart,
  • in order to complie XTT model in the form of HMR type in console: [name-of-hmr-file],
  • run the gox command:
    gox(current, ListOfProcessedTables, ddi)

Run the inference for the following model:


The XPCE-based callbacks consist of the ordinary Prolog predicates that are enriched by XPCE functions. In order to assure the correct integration with HaeRT, the following schema must be used:

xcall xpce_ask_numeric: [AttName] >>> (
        % The body of the callback, which prepares a dialog to appear.
	    % Waiting for OK button

The example of the callback that reads a value from the range [Min; Max] is presented below:

xcall xpce_ask_numeric: [AttName] >>> (alsv_domain(AttName,[Min to Max],numeric),
	new(@dialog,dialog('Select a value')),
		[new(I,int_item(AttName,low := Min, high := Max)),

Run the inference mechanism for the ATM example and trace the callback mechanism:


The Java-based callbacks are the Java programs that are executed by prolog with the help of JPL. To exploit this mechanism, the following classes mysu be used:

  • - an abstract class that must be inherited by all the callbacks
  • - controller
  • - class that stores a data retrieved from a user.

The set of basic components, which can be used to the retrieval data from a user, is prepared to facilitate the callbacks implementation.

  • - creates a list of selectable values. It returns one (selected) value.
  • - allowf for selecting a value from a given range of values. It returns one (selected) value.
  • - creates a list of selectable values. It returns list of all selected values.
  • - GUI for ComboBoxFetcher
  • - GUI for SliderFetcher
  • - GUI for TwoListsFetcher

Download a source code here.


In order to use some of the above components to create callback, you must go through the following steps:

  1. Compile the source code
    javac callbacks/input/*.java skeleton/*.java

    and move it to the HMR file directory.

  2. Modify the HMR file by adding the callback filed to the appropriate attributes.
  3. Define the value of this filed by entering the name of the callback as well as a list of parameters i.e.
    callback: [ask_symbolic_GUI,[day]]
  4. Add the xcall predicates to the HMR file, which execute a given callback:
      xcall ask_symbolic_GUI : [AttName] >>> (
         % Creating controller
    	 % Creating a list of params
    	 Params = [AttName|Domain],
    	 term_to_atom(Params, AtomParams),
             % Execute the callback with the params contained by AtomPArams term.
             % The result will be stored in Answer term.
             % Map the returned value into term and add it the the factbase
  5. Go to HMR file directory.
  6. Run HeaRT tool.
  7. Compile HMR file.
  8. Run the inference mechanism.
  9. The callback should be executed.

Exercise 1
Download the file and run the inference for the HMR file.

Exercise 2

  1. Run HeaRT and load HMR file.
  2. Then run the infenrence mechnism using predicate (gox/3).
  3. Add a new XPCE-based callback, which would present the results of the inference.
  4. Download HMR file.
  5. Add (modify an existing Prolog-based) a new JAVA-based callbacks in the same way as in the previous section.


Z braku lepszego miejsca tutaj studenci wpisują komentarze natury ogólnej do tego lab. 8-)

pl/dydaktyka/piw/2011/systemy_ekspertowe/hekate_iii.txt · ostatnio zmienione: 2019/06/27 15:50 (edycja zewnętrzna) Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0