RooConvIntegrandBinding

class RooConvIntegrandBinding : public RooAbsFunc

    protected:

      void loadValues(const Double_t* xvector, Bool_t clipInvalid = kFALSE) const

    public:

                              RooConvIntegrandBinding(const RooAbsReal& func, const RooAbsReal& model, RooAbsReal& x, RooAbsReal& xprime, const RooArgSet* nset = 0, Bool_t clipInvalid = kFALSE)
                              RooConvIntegrandBinding(const RooConvIntegrandBinding&)
                      virtual ~RooConvIntegrandBinding()
               static TClass* Class()
             virtual Double_t getMaxLimit(UInt_t dimension) const
             virtual Double_t getMinLimit(UInt_t dimension) const
              virtual TClass* IsA() const
             virtual Double_t operator()(const Double_t* xvector) const
                         void setNormalizationSet(const RooArgSet* nset)
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

       const RooAbsReal* _func         
       const RooAbsReal* _model        
      RooAbsRealLValue** _vars         
        const RooArgSet* _nset         
                  Bool_t _xvecValid    
                  Bool_t _clipInvalid  

 'func'  = func(xprime)
 'model' = model(xprime)

 i.e.

 'xprime' is the RRV that should be connected to func and model
          (i.e. the variable that will be integrated over)
 'x'      is RRV that represents the value at which the convolution is calculated
          (this variable should _not_ be connected to func and model)

 this function returns RCBB[x',x] = f[x']*g[x-x'], i.e. the substiturion g[x'] --> g[x-x']
 is taken care internally

 The integral of this binding over its 1st arg yields the convolution (f (x) g)[x]