Athena Developer Guide

Athena
Chapter 2 The framework architecture Version/Issue: 2.0.0
In general an algorithm will be configurable: It will require certain parameters, such as cut-offs, upper
limits on the number of iterations, convergence criteria, etc., to be initialised before the algorithm may
be executed. These parameters may be specified at run time via the job options mechanism. This is
done by the job options service. Though it is not explicitly shown in the figure this component makes
use of the IProperty interface which is implemented by the Algorithm base class.
During its execution an algorithm may wish to make reports on its progress or on errors that occur. All
communication with the outside world should go through the message service component via the
IMessageSvc interface. Use of this interface is discussed in Chapter 13.
As mentioned above, by virtue of its derivation from the Algorithm base class, any concrete
algorithm class implements the IAlgorithm and IProperty interfaces, except for the three
methods initialize(), execute(), and finalize() which must be explicitly implemented
by the concrete algorithm. IAlgorithm is used by the application manager to control top-level
algorithms. IProperty is usually used only by the job options service.
The figure also shows that a concrete algorithm may make use of additional objects internally to aid it
in its function. These private objects do not need to inherit from any particular base class so long as they
are only used internally. These objects are under the complete control of the algorithm object itself and
so care is required to avoid memory leaks etc.
We have used the terms “interface” and “implements” quite freely above. Let us be more explicit about
what we mean. We use the term interface to describe a pure virtual C++ class, i.e. a class with no data
members, and no implementation of the methods that it declares. For example:
class PureAbstractClass {
virtual method1() = 0;
virtual method2() = 0;
}
is a pure abstract class or interface. We say that a class implements such an interface if it is derived
from it, for example:
class ConcreteComponent: public PureAbstractClass {
method1() { }
method2() { }
}
A component which implements more than one interface does so via multiple inheritance, however,
since the interfaces are pure abstract classes the usual problems associated with multiple inheritance do
not occur. These interfaces are identified by a unique number which is available via a global constant of
the form: IID_InterfaceType, such as for example IID_IDataProviderSvc. Using these it
is possible to enquire what interfaces a particular component implements (as shown for example
through the use queryInterface() in the finalize() method of the SimpleAnalysis
example).
page 17