Task initialize
Only active parameters are initialized during this task. In
general,
independent parameters should be initialized first and only then
the
dependent parameters can be processed.
Independent parameters can be initialized in two ways:
- explicit (by the use of domain knowledge);
- implicit.
Explicit parameter initialization is preferable
to an implicit initialization of this
parameter
(which is used only if the present explicit initialization
knowledge
cannot be employed for this parameter for some reason). That is
why the rules representing designer's domain initialization
knowledge
should have higher priority. A typical rule for domain
initialization
has the form:
-
(defrule init-<parameter name>
-
(declare (salience 30))
(job initialize)
?a <- (object (is-a parameter)
-
(param-name ?b)
(active yes)
(param-value nil)
(param-type independent))
... - the calculation of an initialization value ?c
=>
-
(send ?a put-param-value ?c)
)
The implicit initialization depends on the type of parameter
domain
of the initialized parameter. If the domain is enumerative, the
initialization can use the rule:
-
(defrule init-enum
-
(job initialize)
?a <- (object (is-a parameter)
-
(param-value nil)
(active yes)
(param-type independent)
(param-domain enum ?b $?))
=>
-
(send ?a put-param-value ?b)
)
To initialize dependent parameters rules with domain knowledge
(expressing dependence of these parameters on the values of
other parameters) have to be given. These rules are different for
different problems. Such a rule has to test whether all
parameters,
on whose values the initialized dependent parameter depends, are
already initialized. This test corresponds to the condition of
applicability of such a rule.
Since the definition of a parameter can include a priority of
this
parameter, the initialization can be performed in accordance with
the priority of initialized parameters (if more than one
parameter
can be initialized in some step, then the parameter with the
highest
priority is preferred). But in the case of the solution strategy
which initializes all parameters before dealing with constraints
and
their violations, the use of the priority in the initialization
step
does not make any sense.