HiggsThObservables.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef HIGGSTHOBSERVABLES_H
#define HIGGSTHOBSERVABLES_H
 
#include "ThObservable.h"
 
class NPbase;
 
class muggH : public ThObservable {
public:
 
    muggH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBF : public ThObservable {
public:
 
    muVBF(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFgamma : public ThObservable {
public:
 
    muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeWBF : public ThObservable {
public:
 
    mueeWBF(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeWBFPol : public ThObservable {
public:
 
    mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvv : public ThObservable {
public:
 
    mueeHvv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeHvvPol : public ThObservable {
public:
 
    mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
class mueeZBF : public ThObservable {
public:
 
    mueeZBF(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZBFPol : public ThObservable {
public:
 
    mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
class muepWBF : public ThObservable {
public:
 
    muepWBF(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muepZBF : public ThObservable {
public:
 
    muepZBF(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWH : public ThObservable {
public:
 
    muWH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZH : public ThObservable {
public:
 
    muZH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeZH : public ThObservable {
public:
 
    mueeZH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeZHPol : public ThObservable {
public:
 
    mueeZHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
class mueeZllH : public ThObservable {
public:
 
    mueeZllH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeZllHPol : public ThObservable {
public:
 
    mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
class mueeZqqH : public ThObservable {
public:
 
    mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueeZqqHPol : public ThObservable {
public:
 
    mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class aPsk : public ThObservable {
public:
 
    aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class bPsk : public ThObservable {
public:
 
    bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class muVH : public ThObservable {
public:
 
    muVH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFpVH : public ThObservable {
public:
 
    muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttH : public ThObservable {
public:
 
    muttH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mutHq : public ThObservable {
public:
 
    mutHq(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHpttH : public ThObservable {
public:
 
    muggHpttH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mueettH : public ThObservable {
public:
 
    mueettH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueettHPol : public ThObservable {
public:
 
    mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mummH : public ThObservable {
public:
 
    mummH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class GammaHRatio : public ThObservable {
public:
 
    GammaHRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoinvRatio : public ThObservable {
public:
 
    BrHtoinvRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHinvisible : public ThObservable {
public:
 
    BrHinvisible(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHinvisibleNP : public ThObservable {
public:
 
    BrHinvisibleNP(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHexotic : public ThObservable {
public:
 
    BrHexotic(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtovisRatio : public ThObservable {
public:
 
    BrHtovisRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoggRatio : public ThObservable {
public:
 
    BrHtoggRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoWWRatio : public ThObservable {
public:
 
    BrHtoWWRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoWW2l2vRatio : public ThObservable {
public:
 
    BrHtoWW2l2vRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZZRatio : public ThObservable {
public:
 
    BrHtoZZRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZZ4lRatio : public ThObservable {
public:
 
    BrHtoZZ4lRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZZ4eRatio : public ThObservable {
public:
 
    BrHtoZZ4eRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZZ2e2muRatio : public ThObservable {
public:
 
    BrHtoZZ2e2muRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZZ4muRatio : public ThObservable {
public:
 
    BrHtoZZ4muRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZgaRatio : public ThObservable {
public:
 
    BrHtoZgaRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoZgallRatio : public ThObservable {
public:
 
    BrHtoZgallRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZgaeeRatio : public ThObservable {
public:
 
    BrHtoZgaeeRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZgamumuRatio : public ThObservable {
public:
 
    BrHtoZgamumuRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtogagaRatio : public ThObservable {
public:
 
    BrHtogagaRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtomumuRatio : public ThObservable {
public:
 
    BrHtomumuRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtotautauRatio : public ThObservable {
public:
 
    BrHtotautauRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtoccRatio : public ThObservable {
public:
 
    BrHtoccRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtobbRatio : public ThObservable {
public:
 
    BrHtobbRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtogaga_over_mumu_Ratio : public ThObservable {
public:
 
    BrHtogaga_over_mumu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZga_over_mumu_Ratio : public ThObservable {
public:
 
    BrHtoZga_over_mumu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZmumuga_over_mumu_Ratio : public ThObservable {
public:
 
    BrHtoZmumuga_over_mumu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtogaga_over_4l_Ratio : public ThObservable {
public:
 
    BrHtogaga_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtobb_over_4l_Ratio : public ThObservable {
public:
 
    BrHtobb_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHto2l2v_over_4l_Ratio : public ThObservable {
public:
 
    BrHto2l2v_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtotautau_over_4l_Ratio : public ThObservable {
public:
 
    BrHtotautau_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtogaga_over_2e2mu_Ratio : public ThObservable {
public:
 
    BrHtogaga_over_2e2mu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZga_over_4l_Ratio : public ThObservable {
public:
 
    BrHtoZga_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtomumu_over_4l_Ratio : public ThObservable {
public:
 
    BrHtomumu_over_4l_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtomumu_over_4mu_Ratio : public ThObservable {
public:
 
    BrHtomumu_over_4mu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHto4l_over_gaga_Ratio : public ThObservable {
public:
 
    BrHto4l_over_gaga_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZga_over_gaga_Ratio : public ThObservable {
public:
 
    BrHtoZga_over_gaga_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtomumu_over_gaga_Ratio : public ThObservable {
public:
 
    BrHtomumu_over_gaga_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class muggHgaga : public ThObservable {
public:
 
    muggHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHgagaInt : public ThObservable {
public:
 
    muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFHgaga : public ThObservable {
public:
 
    muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHgaga : public ThObservable {
public:
 
    muZHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHgaga : public ThObservable {
public:
 
    muWHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHgaga : public ThObservable {
public:
 
    muVHgaga(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHgaga : public ThObservable {
public:
 
    muttHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muggHZga : public ThObservable {
public:
 
    muggHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class muggHZgamumu : public ThObservable {
public:
 
    muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFHZga : public ThObservable {
public:
 
    muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHZga : public ThObservable {
public:
 
    muZHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHZga : public ThObservable {
public:
 
    muWHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHZga : public ThObservable {
public:
 
    muVHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHZga : public ThObservable {
public:
 
    muttHZga(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muggHZZ : public ThObservable {
public:
 
    muggHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHZZ : public ThObservable {
public:
 
    muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHZZ : public ThObservable {
public:
 
    muZHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHZZ : public ThObservable {
public:
 
    muWHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHZZ : public ThObservable {
public:
 
    muVHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHZZ : public ThObservable {
public:
 
    muttHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHZZ4l : public ThObservable {
public:
 
    muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class muggHZZ4mu : public ThObservable {
public:
 
    muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFHZZ4l : public ThObservable {
public:
 
    muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHZZ4l : public ThObservable {
public:
 
    muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHZZ4l : public ThObservable {
public:
 
    muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHZZ4l : public ThObservable {
public:
 
    muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHZZ4l : public ThObservable {
public:
 
    muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHWW : public ThObservable {
public:
 
    muggHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHWW : public ThObservable {
public:
 
    muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHWW : public ThObservable {
public:
 
    muZHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHWW : public ThObservable {
public:
 
    muWHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHWW : public ThObservable {
public:
 
    muVHWW(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHWW : public ThObservable {
public:
 
    muttHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHWW2l2v : public ThObservable {
public:
 
    muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHWW2l2v : public ThObservable {
public:
 
    muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHWW2l2v : public ThObservable {
public:
 
    muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHWW2l2v : public ThObservable {
public:
 
    muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHWW2l2v : public ThObservable {
public:
 
    muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHWW2l2v : public ThObservable {
public:
 
    muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHmumu : public ThObservable {
public:
 
    muggHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHmumu : public ThObservable {
public:
 
    muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHmumu : public ThObservable {
public:
 
    muZHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHmumu : public ThObservable {
public:
 
    muWHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHmumu : public ThObservable {
public:
 
    muVHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHmumu : public ThObservable {
public:
 
    muttHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muggHtautau : public ThObservable {
public:
 
    muggHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHtautau : public ThObservable {
public:
 
    muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFpVHtautau : public ThObservable {
public:
 
    muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muZHtautau : public ThObservable {
public:
 
    muZHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHtautau : public ThObservable {
public:
 
    muWHtautau(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHtautau : public ThObservable {
public:
 
    muVHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHtautau : public ThObservable {
public:
 
    muttHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muggHbb : public ThObservable {
public:
 
    muggHbb(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVBFHbb : public ThObservable {
public:
 
    muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muZHbb : public ThObservable {
public:
 
    muZHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muWHbb : public ThObservable {
public:
 
    muWHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muVHbb : public ThObservable {
public:
 
    muVHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHbb : public ThObservable {
public:
 
    muttHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFBRinv : public ThObservable {
public:
 
    muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVBFHinv : public ThObservable {
public:
 
    muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVHBRinv : public ThObservable {
public:
 
    muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muVHinv : public ThObservable {
public:
 
    muVHinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muppHmumu : public ThObservable {
public:
 
    muppHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muppHZga : public ThObservable {
public:
 
    muppHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muggHH2ga2b : public ThObservable {
public:
 
    muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muttHZbbboost : public ThObservable {
public:
 
    muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class UpperLimit_ppHZgammaA : public ThObservable {
public:
 
    UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
    
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class UpperLimit_ppHZgammaA13 : public ThObservable {
public:
 
    UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class UpperLimit_ppHZgammaC13 : public ThObservable {
public:
 
    UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class UpperLimit_ppHZgammaC : public ThObservable {
public:
 
    UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class cg_plus_ct : public ThObservable {
public:
 
    cg_plus_ct(const StandardModel& SM_i);
 
    double computeThValue();
private:
    const NPbase* myNPbase;
};
 
class cga_plus_ct : public ThObservable {
public:
 
    cga_plus_ct(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cg_minus_cga : public ThObservable {
public:
 
    cg_minus_cga(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cV_plus_cb : public ThObservable {
public:
 
    cV_plus_cb(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cV_plus_ctau : public ThObservable {
public:
 
    cV_plus_ctau(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cb_minus_cc : public ThObservable {
public:
 
    cb_minus_cc(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cb_minus_ctau : public ThObservable {
public:
 
    cb_minus_ctau(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class cc_minus_ctau : public ThObservable {
public:
 
    cc_minus_ctau(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
//  Full signal strengths at lepton colliders
//  -----------------------------------------
 
class mueeZHbb : public ThObservable {
public:
 
    mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHcc : public ThObservable {
public:
 
    mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHgg : public ThObservable {
public:
 
    mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHWW : public ThObservable {
public:
 
    mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHtautau : public ThObservable {
public:
 
    mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHZZ : public ThObservable {
public:
 
    mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHZga : public ThObservable {
public:
 
    mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHgaga : public ThObservable {
public:
 
    mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHmumu : public ThObservable {
public:
 
    mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHBRinv : public ThObservable {
public:
 
    mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHinv : public ThObservable {
public:
 
    mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHbbPol : public ThObservable {
public:
 
    mueeZHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHccPol : public ThObservable {
public:
 
    mueeZHccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
    
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHggPol : public ThObservable {
public:
 
    mueeZHggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHWWPol : public ThObservable {
public:
 
    mueeZHWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHtautauPol : public ThObservable {
public:
 
    mueeZHtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHZZPol : public ThObservable {
public:
 
    mueeZHZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHZgaPol : public ThObservable {
public:
 
    mueeZHZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHgagaPol : public ThObservable {
public:
 
    mueeZHgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHmumuPol : public ThObservable {
public:
 
    mueeZHmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
class mueeZHBRinvPol : public ThObservable {
public:
 
    mueeZHBRinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeZHinvPol : public ThObservable {
public:
 
    mueeZHinvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeWBFbb : public ThObservable {
public:
 
    mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFbbPol : public ThObservable {
public:
 
    mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeWBFcc : public ThObservable {
public:
 
    mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFgg : public ThObservable {
public:
 
    mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFWW : public ThObservable {
public:
 
    mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFtautau : public ThObservable {
public:
 
    mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFZZ : public ThObservable {
public:
 
    mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFZga : public ThObservable {
public:
 
    mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFgaga : public ThObservable {
public:
 
    mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeWBFmumu : public ThObservable {
public:
 
    mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvbb : public ThObservable {
public:
 
    mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvbbPol : public ThObservable {
public:
 
    mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvcc : public ThObservable {
public:
 
    mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvccPol : public ThObservable {
public:
 
    mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvgg : public ThObservable {
public:
 
    mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvggPol : public ThObservable {
public:
 
    mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvWW : public ThObservable {
public:
 
    mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvWWPol : public ThObservable {
public:
 
    mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvtautau : public ThObservable {
public:
 
    mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvtautauPol : public ThObservable {
public:
 
    mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvZZ : public ThObservable {
public:
 
    mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvZZPol : public ThObservable {
public:
 
    mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvZga : public ThObservable {
public:
 
    mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvZgaPol : public ThObservable {
public:
 
    mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvgaga : public ThObservable {
public:
 
    mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvgagaPol : public ThObservable {
public:
 
    mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueeHvvmumu : public ThObservable {
public:
 
    mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeHvvmumuPol : public ThObservable {
public:
 
    mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
 
class mueeZBFbb : public ThObservable {
public:
 
    mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZBFbbPol : public ThObservable {
public:
 
    mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
class mueettHbb : public ThObservable {
public:
 
    mueettHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueettHbbPol : public ThObservable {
public:
 
    mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
 
class muepWBFbb : public ThObservable {
public:
 
    muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFcc : public ThObservable {
public:
 
    muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFgg : public ThObservable {
public:
 
    muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFWW2l2v : public ThObservable {
public:
 
    muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFZZ4l : public ThObservable {
public:
 
    muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFgaga : public ThObservable {
public:
 
    muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepWBFtautau : public ThObservable {
public:
 
    muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFbb : public ThObservable {
public:
 
    muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFcc : public ThObservable {
public:
 
    muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFgg : public ThObservable {
public:
 
    muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFWW2l2v : public ThObservable {
public:
 
    muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFZZ4l : public ThObservable {
public:
 
    muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFgaga : public ThObservable {
public:
 
    muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muepZBFtautau : public ThObservable {
public:
 
    muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
// -----------------------------------------------------------------------------
// STXS bins
// -----------------------------------------------------------------------------
 
class STXSggH_VBFtopo_j3v_4l : public ThObservable {
public:
 
    STXSggH_VBFtopo_j3v_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH_VBFtopo_j3_4l : public ThObservable {
public:
 
    STXSggH_VBFtopo_j3_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH0j4l : public ThObservable {
public:
 
    STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH1j_pTH_0_60_4l : public ThObservable {
public:
 
    STXSggH1j_pTH_0_60_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH1j_pTH_60_120_4l : public ThObservable {
public:
 
    STXSggH1j_pTH_60_120_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH1j_pTH_120_200_4l : public ThObservable {
public:
 
    STXSggH1j_pTH_120_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH1j_pTH_200_4l : public ThObservable {
public:
 
    STXSggH1j_pTH_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH2j_pTH_0_200_4l : public ThObservable {
public:
 
    STXSggH2j_pTH_0_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH2j_pTH_0_60_4l : public ThObservable {
public:
 
    STXSggH2j_pTH_0_60_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH2j_pTH_60_120_4l : public ThObservable {
public:
 
    STXSggH2j_pTH_60_120_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH2j_pTH_120_200_4l : public ThObservable {
public:
 
    STXSggH2j_pTH_120_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSggH2j_pTH_200_4l : public ThObservable {
public:
 
    STXSggH2j_pTH_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHqq_VBFtopo_Rest_4l : public ThObservable {
public:
 
    STXSqqHqq_VBFtopo_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHqq_VBFtopo_j3v_4l : public ThObservable {
public:
 
    STXSqqHqq_VBFtopo_j3v_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHqq_VBFtopo_j3_4l : public ThObservable {
public:
 
    STXSqqHqq_VBFtopo_j3_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHqq_VHtopo_4l : public ThObservable {
public:
 
    STXSqqHqq_VHtopo_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHqq_Rest_4l : public ThObservable {
public:
 
    STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHqq_pTj_200_4l : public ThObservable {
public:
 
    STXSqqHqq_pTj_200_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_0_250_4l : public ThObservable {
public:
 
    STXSqqHlv_pTV_0_250_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_0_150_4l : public ThObservable {
public:
 
    STXSqqHlv_pTV_0_150_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_150_250_0j_4l : public ThObservable {
public:
 
    STXSqqHlv_pTV_150_250_0j_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_150_250_1j_4l : public ThObservable {
public:
 
    STXSqqHlv_pTV_150_250_1j_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_250_4l : public ThObservable {
public:
 
    STXSqqHlv_pTV_250_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_0_150_4l : public ThObservable {
public:
 
    STXSqqHll_pTV_0_150_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_150_250_4l : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_150_250_0j_4l : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_0j_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHll_pTV_150_250_1j_4l : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_1j_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHll_pTV_250_4l : public ThObservable {
public:
 
    STXSqqHll_pTV_250_4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSttHtH4l : public ThObservable {
public:
 
    STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHlv_pTV_0_250_bb : public ThObservable {
public:
 
    STXSqqHlv_pTV_0_250_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_0_150_bb : public ThObservable {
public:
 
    STXSqqHlv_pTV_0_150_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_150_250_0j_bb : public ThObservable {
public:
 
    STXSqqHlv_pTV_150_250_0j_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_150_250_1j_bb : public ThObservable {
public:
 
    STXSqqHlv_pTV_150_250_1j_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHlv_pTV_250_bb : public ThObservable {
public:
 
    STXSqqHlv_pTV_250_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_0_150_bb : public ThObservable {
public:
 
    STXSqqHll_pTV_0_150_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_150_250_bb : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSqqHll_pTV_150_250_0j_bb : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_0j_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHll_pTV_150_250_1j_bb : public ThObservable {
public:
 
    STXSqqHll_pTV_150_250_1j_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSqqHll_pTV_250_bb : public ThObservable {
public:
 
    STXSqqHll_pTV_250_bb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSWHqqHqq_VBFtopo_j3v_2b : public ThObservable {
public:
 
    STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSWHqqHqq_VBFtopo_j3_2b : public ThObservable {
public:
 
    STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSWHqqHqq_VH2j_2b : public ThObservable {
public:
 
    STXSWHqqHqq_VH2j_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSWHqqHqq_Rest_2b : public ThObservable {
public:
 
    STXSWHqqHqq_Rest_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSWHqqHqq_pTj1_200_2b : public ThObservable {
public:
 
    STXSWHqqHqq_pTj1_200_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSZHqqHqq_VBFtopo_j3v_2b : public ThObservable {
public:
 
    STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSZHqqHqq_VBFtopo_j3_2b : public ThObservable {
public:
 
    STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSZHqqHqq_VH2j_2b : public ThObservable {
public:
 
    STXSZHqqHqq_VH2j_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class STXSZHqqHqq_Rest_2b : public ThObservable {
public:
 
    STXSZHqqHqq_Rest_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class STXSZHqqHqq_pTj1_200_2b : public ThObservable {
public:
 
    STXSZHqqHqq_pTj1_200_2b(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
 
//-----------------------------------------------------------------------------------------
//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
//-----------------------------------------------------------------------------------------
 
class muTHUggHgaga : public ThObservable {
public:
 
    muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHgaga : public ThObservable {
public:
 
    muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHgaga : public ThObservable {
public:
 
    muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHgaga : public ThObservable {
public:
 
    muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHgaga : public ThObservable {
public:
 
    muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHgaga : public ThObservable {
public:
 
    muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUggHZga : public ThObservable {
public:
 
    muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class muTHUggHZgamumu : public ThObservable {
public:
 
    muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVBFHZga : public ThObservable {
public:
 
    muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHZga : public ThObservable {
public:
 
    muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHZga : public ThObservable {
public:
 
    muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHZga : public ThObservable {
public:
 
    muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHZga : public ThObservable {
public:
 
    muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUggHZZ : public ThObservable {
public:
 
    muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHZZ : public ThObservable {
public:
 
    muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHZZ : public ThObservable {
public:
 
    muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHZZ : public ThObservable {
public:
 
    muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHZZ : public ThObservable {
public:
 
    muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHZZ : public ThObservable {
public:
 
    muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUggHZZ4l : public ThObservable {
public:
 
    muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class muTHUggHZZ4mu : public ThObservable {
public:
 
    muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVBFHZZ4l : public ThObservable {
public:
 
    muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHZZ4l : public ThObservable {
public:
 
    muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHZZ4l : public ThObservable {
public:
 
    muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHZZ4l : public ThObservable {
public:
 
    muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHZZ4l : public ThObservable {
public:
 
    muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUggHWW : public ThObservable {
public:
 
    muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHWW : public ThObservable {
public:
 
    muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHWW : public ThObservable {
public:
 
    muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHWW : public ThObservable {
public:
 
    muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHWW : public ThObservable {
public:
 
    muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHWW : public ThObservable {
public:
 
    muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUggHWW2l2v : public ThObservable {
public:
 
    muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHWW2l2v : public ThObservable {
public:
 
    muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHWW2l2v : public ThObservable {
public:
 
    muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHWW2l2v : public ThObservable {
public:
 
    muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHWW2l2v : public ThObservable {
public:
 
    muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHWW2l2v : public ThObservable {
public:
 
    muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUggHmumu : public ThObservable {
public:
 
    muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHmumu : public ThObservable {
public:
 
    muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHmumu : public ThObservable {
public:
 
    muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHmumu : public ThObservable {
public:
 
    muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHmumu : public ThObservable {
public:
 
    muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHmumu : public ThObservable {
public:
 
    muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUggHtautau : public ThObservable {
public:
 
    muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHtautau : public ThObservable {
public:
 
    muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHtautau : public ThObservable {
public:
 
    muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHtautau : public ThObservable {
public:
 
    muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHtautau : public ThObservable {
public:
 
    muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHtautau : public ThObservable {
public:
 
    muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUggHbb : public ThObservable {
public:
 
    muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVBFHbb : public ThObservable {
public:
 
    muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUZHbb : public ThObservable {
public:
 
    muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUWHbb : public ThObservable {
public:
 
    muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUVHbb : public ThObservable {
public:
 
    muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class muTHUttHbb : public ThObservable {
public:
 
    muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVBFBRinv : public ThObservable {
public:
 
    muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVBFHinv : public ThObservable {
public:
 
    muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVHBRinv : public ThObservable {
public:
 
    muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class muTHUVHinv : public ThObservable {
public:
 
    muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class BrHto2l2v_over_gaga_Ratio : public ThObservable {
public:
 
    BrHto2l2v_over_gaga_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
#endif  /* HIGGSTHOBSERVABLES_H */