ConFLIP++ User Interface

In the following we will use a simple example, which is actually identical to the one used in the ConFLIP++ Sample Code part of DocuFLIP++. Although very simple and not too realistic it should give you a short impression of how to use the ConFLIP++ user interface. It is also recommended, although not necessary, to go through the documentation of FLIP++ in DocuFLIP++. There are many similarities between ConFLIP++ and FLIP++ as ConFLIP++ is based on FLIP++.

One of the features of ConFLIP++ is that is goes a little bit farther than FLIP++ when it comes to the representation of constraints. Whereas in FLIP++ you simply define linguistic variables with their linguistic terms and the rules that show the interrelationship between the variables, ConFLIP++ also allows a direct constraint definition and then generates the appropriate rules automatically. Generally speaking, the constraints can be divided into two groups: The compare constraints and the concat constraints. The former allows us to compare a linguistic variable with a specific value and to evaluate how well this comparison is satisfied, the latter constraint type is an aggregation of two other constraints. One can easily see, that the concat constraint hence enables us to build a hierarchy of constraints or put in another way, a constraints tree. This is especially useful when you have a system where a specific order is inherent and where some constraints are underlying constraints for various other constraints.

Similarly to the ConFLIP++ Sample Code we build our example system by using some predefined parameters and then create the hierarchy of constraints that refer to chemical compatibilities, which are relevant to the process of steelmaking.

Main application window

Initially, we find ourselves in the main application window. It shows the states of the data pool, which is formed by the Table that defines the operators functionality with the linguistic terms used by the linguistic variables and the ParameterSet defining the shape of membership functions. Also, the set of constraints that are currently defined is displayed.

How to define linguistic terms

First, we start with the linguistic terms after selecting the item lingusitc terms in the menu data pool the linguistic terms window is displayed on the front. Here new linguistic variables (set of terms) and linguistic terms can be added, edited, and deleted. Furthermore it is possible to read and write from/to a file.

How to define operator functionality

Now we proceed with specifying a table, which is necessary in order to tell ConFLIP++ how an operator should be applied to input values. Having selected the item tables in the data pool window brings us to the corresponding table window. There, a list of tables is displayed. Moreover, for the currently selected table the dilatation types, operators, and functionality of the selected operator for the selected dilatation are shown. Tables have to specified for both types of constraints.

Besides, we must distinguish between a fuzzy and crisp input/output value in the case of compare constraints. With concat constraints it is also possible to have mixed values because there are always two input parameters, i.e. the two constraints that are to be concatenated. To create a new table one either chooses the NEW compare table or the NEW concat table button at the bottom of the window. Then a windows prompts for the name of the table and the particular fuzzy/crisp/mixed input and output terms, which are the sets of linguistic terms defined in the previous paragraph.

How to define sets of parameters

In order to specify the shape of the membership functions of linguistic variables it is also necessary to have paramter sets that describe the functions. A parameter set can be created by clicking the item membership parameters of the data pool window. The window that appears on the screen is exaclty the same is in the FLIP++ User Interface. First a list of parameter sets is displayed, then the parameters of the currently selected set. The values of the parameter set are identical to the ones used in the ConFLIP++ Sample Code. These parameters are used as default values for the linguistic variables that are created for the representation of a constraint. So, contrary to FLIP++, where linguistic variables are created explicitly by the user, in ConFLIP++ the user creates constraints and the system makes implicitly linguistic variables that are attached to these constraints.

How to define constraint information

The last item of the data pool menu are the constraint infos, these are the descriptions of the constraints. In the specific window you can either choose to add a compare or a concat constraint. The creation is rather straightforward, you just have to enter the particular parameters of the constraints. In our example, we created exactly the same infos for the constraints as in the ConFLIP++ sample code. Furthermore, the add info to SetOfConstraint button enables the user to attach an info to certain, already defined, set of constraints.

How to define constraints

The menu set of constraints is devoted to the handling of the constraints. Until now, we have only set the framework for the constraints. Now if we want to create them, we can either load already defined constraints from a file, or we create new ones by using the items NEW or NEW with defaults.

Furthermore, an existing set of constrains can be edited when clicking the item constraint handling. All these options lead to the same window, which is almost exactly the same as the FLIP++ user interface. For that reason we will be refering to the description given for any particulars.

Roughly speaking, the main differences to the FLIP user interface are: instead of linguistic variables you create constraints (either concat or compare), internally these are in turn represented as linguistic variables (CombinedVariable objects). Furthermore, it is possible to derive constraints directly from the definition of the constraint infos with the item NEW info from container. Of course the created constraints can be edited and deleted. The menus terms/msf and rules behave in the same way as in the FLIP++ user interface. Also, slightly different from FLIP++ the switch var/con term chooses between either displaying the terms of the variable contained in a compare constraint or the terms of the compare constraint variable itself. For the concat constraint this switch does not have a meaning.

Again, please note that you always get a default set of rules for each constraint, which of course can be modified. One can easily see that in principle the rules created by ConFLIP++ according to the table, parametersets, linguistic terms for a specific constraint could also be modified with FLIP++. But this would mean a lot of tedious work, which can otherwise be done automatically. Modifying the rules generated by ConFLIP++ is just the fine-tuning work that might be necessary to obtain reasonable results.

How to evaluate constraints and to define evaluated constraints

Now, before proceeding with evaluating a constraint it is necessary to define a set of evaluated constraints, where each evaluation of a constraint will be stored. This is either achieved by choosing the items READandNEW, or NEW with defaults in the menu evaluated constraints. The upcoming window looks similar to the set of constraints window. As in the ConFLIP++ Sample Code two evaluations can be aggregated to an overall evaluation, which again shows the hierarchical composition of different evaluations. The other components like terms, rules, and membership functions are handled in the same way as in the set of constraints window.

Going back to the set of constraints window, we can start the evaluation of a constraint by choosing it in the list of constraints and clicking the evaluate button. This brings a window to the screen prompting for the name of the evaluation and the values which can be set for the input variables. Prior to evaluation it is necessary to set values for all the variables used in the underlying constraints which the ConFLIP++ always prompts the user for . Then an evaluated constraint is created, which can be seen in the evaluated constraints window.

Back to DocuFLIP++ overview StarFLIP home page

(c)1996 Andreas Raggl, Mazen Younes, Markus Bonner, Wolfgang Slany

Last modified: Tue Jun 24 15:35:49 MET-DST 1997 by StarFLIP Team