GammaLib

The underlying question is also of how to split the model evaluation (i.e. GObservation::model) and the Npred computation (i.e. GObservation::npred) between the GObservation, GModelSky and GResponse classes. The current split does not seem to be consistent between model and Npred computation, and maybe clear interfaces could be found by doing a more clean split.

Doing computations in the model requires carrying GObservation information in the GModelSky methods. For Npred, the only method in GModelSky that is currently used is GModelSky::npred and the reason for having this method in GModelSky is that a different implementation of this method is needed for data space models (i.e. no convolution with the response). So this looks fine.

Doing GObservation::npred(GModel&) in GObservation (and the time and energy integrations) seems not really required. The integration over the data space could also be done in GModel. This would probably provide a clearer interface.

The GResponse methods

    virtual double      irf(const GEvent&       event,
                            const GPhoton&      photon,
                            const GObservation& obs) const = 0;
    virtual double      npred(const GPhoton&      photon,
                              const GObservation& obs) const = 0;

are not really required by any code in GammaLib, although they are used in the response computations. Nevertheless, these are not the central methods used in the GModelSky response computations. The relevant methods are

    virtual double   irf(const GEvent&       event,
                         const GSource&      source,
                         const GObservation& obs) const;
    virtual double   npred(const GSource&      source,
                           const GObservation& obs) const;

which are the variants where the photon gets replaced by a GSource object. In that way, spatial model information is piped to the response classes that can be used for efficient response computation.

The solution will be a refactoring of the response code by removing most of the former virtual methods and by introducing a convolve() method that performs the convolution of a sky model with the IRF. In addition, a nroi() method will be added that replaces the former npred() methods. The time and energy integration that actually exists in the GModelSky class will then be moved to the GResponse classes. Eventually, a base implementation of convolve() can exist in GResponse that provides the time and energy integration, but we may also think about changing the integration order to benefit from the energy independence (and time independence) of most spatial models.

class GResponse : public GBase {

public:
    // Constructors and destructors
    GResponse(void);
    GResponse(const GResponse& rsp);
    virtual ~GResponse(void);

    // Operators
    virtual GResponse& operator=(const GResponse& rsp);

    // Pure virtual methods
    virtual void        clear(void) = 0;
    virtual GResponse*  clone(void) const = 0;
    virtual std::string classname(void) const = 0;
    virtual bool        use_edisp(void) const = 0;
    virtual bool        use_tdisp(void) const = 0;
    virtual double      irf(const GEvent&       event,
                            const GPhoton&      photon,
                            const GObservation& obs) const = 0;
    virtual double      convolve(const GModelSky&    model,
                                 const GEvent&       event,
                                 const GObservation& obs) const = 0;
    virtual double      nroi(const GModelSky&    model,
                             const GEnergy&      obsEng,
                             const GTime&        obsTime,
                             const GObservation& obs) const = 0;
    virtual std::string print(const GChatter& chatter = NORMAL) const = 0;