Athena Developer Guide

Athena
Chapter 5 Writing algorithms Version/Issue: 2.0.0
Just because an algorithm derives from the Algorithm base class does not mean that it is limited to
using or overriding only the methods defined by the base class. In general, your code will be much
better structured (i.e. understandable, maintainable, etc.) if you do not, for example, implement the
execute() method as a single block of 100 lines, but instead define your own utility methods and
classes to better structure the code.
If an algorithm fails in some manner, e.g. a fit fails to converge, or its data is nonsense it should return
from the execute() method with StatusCode::FAILURE. This will cause the application
manager to stop processing events and end the job. This default behaviour can be modified by setting
the .ErrorMax job option to something greater than 1. In this case a message will
be printed, but the job will continue as if there had been no error, and just increment an error count. The
job will only stop if the error count reaches the ErrorMax limit set in the job option.
The framework (the Algorithm base class) calls the execute() method within a try/catch clause.
This means that any exception not handled in the execution of an Algorithm will be caught at the level
of sysExecute() implemented in the base class. The behaviour on these exceptions is identical to
that described above for errors.
Finalization The finalize() method is called at the end of the job. It can be used to analyse
statistics, fit histograms, or whatever you like. Similarly to initialization, the framework invokes a
sysFinalize() method which in turn invokes the finalize() method of the algorithm and of
any sub-algorithms.
Monitoring of the execution (e.g. cpu usage) of each Algorithm instance is performed by auditors under
control of the Auditor service (described in Chapter 13). This monitoring can be turned on or off with
the boolean properties AuditInitialize, AuditExecute, AuditFinalize.
The following is a list of things to do when implementing an algorithm.
• Derive your algorithm from the Algorithm base class.
• Provide the appropriate constructor and the three methods initialize(), execute()
and finalize().
• Make sure you have implemented a factory by adding the magic two lines of code (see 5.3.1).
5.4 Nesting algorithms
The application manager is responsible for initializing, executing once per event, and finalizing the set
of top level algorithms, i.e. the set of algorithms specified in the job options file. However such a
simple linear structure is very limiting. You may wish to execute some algorithms only for specific
types of event, or you may wish to “loop” over an algorithm’s execute method. Within the Athena
application framework the way to have such control is via the nesting of algorithms or through
algorithm sequences (described in section 5.5). A nested (or sub-) algorithm is one which is created by,
and thus belongs to and is controlled by, another algorithm (its parent) as opposed to the application
manager. In this section we discuss a number of points which are specific to sub-algorithms.
page 29