TransverseFuzzinessCalculator.h

//
// This code calculates an overall "fuzzinness"
// of the event given the matrix which defines
// probabilities of particle assignments to jets.
//

#ifndef TransverseFuzzinessCalculator_h
#define TransverseFuzzinessCalculator_h

#include "AbsFuzzinessCalculator.h"

namespace stab {
    class TransverseFuzzinessCalculator : public AbsFuzzinessCalculator
    {
    public:
        //
        // Flags which modify the code behavior have the following
        // meaning:
        //
        // divideTotalFuzzinessByNJets :  if true, the total event
        //   fuzziness will be divided by the number of jets in
        //   the event.
        //
        // divideFuzzinessByPtSum      :  if true, the contribution
        //   of each jet into the overall event fuzziness will be
        //   weighted by the jet Pt.
        //
        // addInQuadrature             :  if true, fuzziness values
        //   for individual jets will be combined in quadrature in
        //   order to form the event fuzziness (otherwise they are
        //   combined linearly).
        //
        // It does not make much sense to set true both
        // "divideTotalFuzzinessByNJets" and "divideFuzzinessByPtSum".
        //
        inline TransverseFuzzinessCalculator(bool divideTotalFuzzinessByNJets,
                                             bool divideFuzzinessByPtSum,
                         bool addInQuadrature)
            : divideByNjets_(divideTotalFuzzinessByNJets),
              divideByPt_(divideFuzzinessByPtSum) ,
          addInQuadrature_(addInQuadrature){}

        inline virtual ~TransverseFuzzinessCalculator() {}

        // Inspectors
        inline bool divideByNjets() const {return divideByNjets_;}
        inline bool divideByPt() const {return divideByPt_;}

        // "initialParticles" and "finalJets" are the collections
        // of particles and jets in the event of interest.
        //
        // "weights" is the left-stochastic matrix of weights,
        // dimensioned nJets x nParts. The order of rows/columns
        // should correspond to the order of jets/particles
        // in the relevant input collection.
        //
        // The overall event jet fuzzinness is returned. Fuzzinness
        // values for individual jets are calculated according to
        // the generalized multinomial distribution assumption. They
        // are placed into the "jetFuzziness" array on exit. The
        // length of this array (provided as "lenJetFuzziness"
        // argument) should be equal to or larger than the number
        // of jets.
        //
        double calculate(const Event &initialParticles, 
                         const Event &finalJets,
                         const double *weights,
                         unsigned nJets, unsigned nParts, 
                         bool lastFinalJetIsUnclustered,
                         double *jetFuzziness, unsigned lenJetFuzziness) const;
    private:
        virtual void singleJetFuzziness(
            const double *ptValues, const double *weights, unsigned len,
            double* thisJetFuzzines, double* eventFuzzinesContribution) const;

        mutable std::vector<double> ptStorage_;
        bool divideByNjets_;
        bool divideByPt_;
    bool addInQuadrature_;
    };
}

#endif // TransverseFuzzinessCalculator_h