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, 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, 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, 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 muWHpT250 : public ThObservable {
public:
 
    muWHpT250(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 muZHpT250 : public ThObservable {
public:
 
    muZHpT250(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mueeZHGen : public ThObservable {
public:
 
    mueeZHGen(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 mueeZH : public ThObservable {
public:
 
    mueeZH(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, 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, 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 muVHpT250 : public ThObservable {
public:
 
    muVHpT250(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, 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 mummHNWA : public ThObservable {
public:
 
    mummHNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
// -----------------------------------------------------------------------------
// Decay widths
// -----------------------------------------------------------------------------
 
class GammaHtoggRatio : public ThObservable {
public:
 
    GammaHtoggRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtoWWRatio : public ThObservable {
public:
 
    GammaHtoWWRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class GammaHtoZZRatio : public ThObservable {
public:
 
    GammaHtoZZRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtoZgaRatio : public ThObservable {
public:
 
    GammaHtoZgaRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtogagaRatio : public ThObservable {
public:
 
    GammaHtogagaRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtomumuRatio : public ThObservable {
public:
 
    GammaHtomumuRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtotautauRatio : public ThObservable {
public:
 
    GammaHtotautauRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtossRatio : public ThObservable {
public:
 
    GammaHtossRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtoccRatio : public ThObservable {
public:
 
    GammaHtoccRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class GammaHtobbRatio : public ThObservable {
public:
 
    GammaHtobbRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class GammaHRatio : public ThObservable {
public:
 
    GammaHRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
// -----------------------------------------------------------------------------
// Branching Ratios
// -----------------------------------------------------------------------------
 
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 BrHtoZZRatio : public ThObservable {
public:
 
    BrHtoZZRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoVVRatio : public ThObservable {
public:
 
    BrHtoVVRatio(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;
};
 
 
// -----------------------------------------------------------------------------
// More 4 fermion decays
// -----------------------------------------------------------------------------
 
class BrHto2l2vRatio : public ThObservable {
public:
 
    BrHto2l2vRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoevmuvRatio : public ThObservable {
public:
 
    BrHtoevmuvRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto2e2vRatio : public ThObservable {
public:
 
    BrHto2e2vRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto2mu2vRatio : public ThObservable {
public:
 
    BrHto2mu2vRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto4lRatio : public ThObservable {
public:
 
    BrHto4lRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto4eRatio : public ThObservable {
public:
 
    BrHto4eRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto4muRatio : public ThObservable {
public:
 
    BrHto4muRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHto2e2muRatio : public ThObservable {
public:
 
    BrHto2e2muRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtolljjRatio : public ThObservable {
public:
 
    BrHtolljjRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
class BrHtolvjjRatio : public ThObservable {
public:
 
    BrHtolvjjRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtolv_lvorjjRatio : public ThObservable {
public:
 
    BrHtolv_lvorjjRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoll_vvorjjRatio : public ThObservable {
public:
 
    BrHtoll_vvorjjRatio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
// -----------------------------------------------------------------------------
// Ratios of BR (ratios with SM)
// -----------------------------------------------------------------------------
 
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 BrHtoZga_over_4mu_Ratio : public ThObservable {
public:
 
    BrHtoZga_over_4mu_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtoZmumuga_over_4mu_Ratio : public ThObservable {
public:
 
    BrHtoZmumuga_over_4mu_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 BrHto2l2v_over_gaga_Ratio : public ThObservable {
public:
 
    BrHto2l2v_over_gaga_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
class BrHtobb_over_cc_Ratio : public ThObservable {
public:
 
    BrHtobb_over_cc_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtogaga_over_gg_Ratio : public ThObservable {
public:
 
    BrHtogaga_over_gg_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtogg_over_bb_Ratio : public ThObservable {
public:
 
    BrHtogg_over_bb_Ratio(const StandardModel& SM_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
};
 
 
 
class BrHtogg_over_cc_Ratio : public ThObservable {
public:
 
    BrHtogg_over_cc_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 mutHgaga : public ThObservable {
public:
 
    mutHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                           //AG:added
 
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 muggHpbbH_Hgaga : public ThObservable {
public:
 
    muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                    //AG:added
 
 
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 muggHpttHptHpbbH_HZga : public ThObservable {
public:
 
    muggHpttHptHpbbH_HZga(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
 
class muVBFpVH_HZga : public ThObservable {
public:
 
    muVBFpVH_HZga(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 muttHptH_HZZ : public ThObservable {
public:
 
    muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                       //AG:added
 
class muttHptH_Hgaga : public ThObservable {
public:
 
    muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                     //AG:added
 
class muttHptH_Hmumu : public ThObservable {
public:
 
    muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                     //AG:added
 
class muggHpbbH_HZZ : public ThObservable {
public:
 
    muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                      //AG:added
 
 
 
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 muttHptH_HWW : public ThObservable {
public:
 
    muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                       //AG:added
 
class muggHpbbH_HWW : public ThObservable {
public:
 
    muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                      //AG:added
 
 
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 muttHVV : public ThObservable {
public:
 
    muttHVV(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 muggHpttHptHpbbH_Hmumu : public ThObservable {
public:
 
    muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};             //AG:added
 
class muVBFpVH_Hmumu : public ThObservable {
public:
 
    muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                     //AG:added
 
 
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 muttHptH_Htautau : public ThObservable {
public:
 
    muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                   //AG:added
 
class muggHpbbH_Htautau : public ThObservable {
public:
 
    muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                  //AG:added
 
 
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 muttHptH_Hbb : public ThObservable {
public:
 
    muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                        //AG:added
 
class muggHpVBFpbbH_Hbb : public ThObservable {
public:
 
    muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};                  //AG:added
 
 
 
class muVHcc : public ThObservable {
public:
 
    muVHcc(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 muttHgagaZeeboost : public ThObservable {
public:
 
    muttHgagaZeeboost(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
//AG:begin
class ggHgaga : public ThObservable {
public:
 
    ggHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ggHZZ : public ThObservable {
public:
 
    ggHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ggHWW : public ThObservable {
public:
 
    ggHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ggHtautau : public ThObservable {
public:
 
    ggHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
//--------------------------------------------------
 
class VBFHgaga : public ThObservable {
public:
 
    VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class VBFHZZ : public ThObservable {
public:
 
    VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class VBFHWW : public ThObservable {
public:
 
    VBFHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class VBFHtautau : public ThObservable {
public:
 
    VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
//--------------------------------------------------
 
class WHgaga : public ThObservable {
public:
 
    WHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class WHWW : public ThObservable {
public:
 
    WHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class WHtautau : public ThObservable {
public:
 
    WHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class WHbb : public ThObservable {
public:
 
    WHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
//--------------------------------------------------
 
class ZHgaga : public ThObservable {
public:
 
    ZHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ZHWW : public ThObservable {
public:
 
    ZHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ZHtautau : public ThObservable {
public:
 
    ZHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ZHbb : public ThObservable {
public:
 
    ZHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
//--------------------------------------------------
 
class ttHgaga : public ThObservable {
public:
 
    ttHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ttHWW : public ThObservable {
public:
 
    ttHWW(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ttHtautau : public ThObservable {
public:
 
    ttHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class ttHbb : public ThObservable {
public:
 
    ttHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
//AG:end
 
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 e+ e- colliders
//  ----------------------------------------
 
class mueeZHbb : public ThObservable {
public:
 
    mueeZHbb(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 mueeZHcc : public ThObservable {
public:
 
    mueeZHcc(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 mueeZHss : public ThObservable {
public:
 
    mueeZHss(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 mueeZHgg : public ThObservable {
public:
 
    mueeZHgg(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 mueeZHWW : public ThObservable {
public:
 
    mueeZHWW(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 mueeZHtautau : public ThObservable {
public:
 
    mueeZHtautau(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 mueeZHZZ : public ThObservable {
public:
 
    mueeZHZZ(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 mueeZHZga : public ThObservable {
public:
 
    mueeZHZga(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 mueeZHgaga : public ThObservable {
public:
 
    mueeZHgaga(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 mueeZHmumu : public ThObservable {
public:
 
    mueeZHmumu(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 mueeZHBRinv : public ThObservable {
public:
 
    mueeZHBRinv(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 mueeZHinv : public ThObservable {
public:
 
    mueeZHinv(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, 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, 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 mueeWBFgg : public ThObservable {
public:
 
    mueeWBFgg(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 mueeWBFWW : public ThObservable {
public:
 
    mueeWBFWW(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 mueeWBFtautau : public ThObservable {
public:
 
    mueeWBFtautau(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 mueeWBFZZ : public ThObservable {
public:
 
    mueeWBFZZ(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 mueeWBFZga : public ThObservable {
public:
 
    mueeWBFZga(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 mueeWBFgaga : public ThObservable {
public:
 
    mueeWBFgaga(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 mueeWBFmumu : public ThObservable {
public:
 
    mueeWBFmumu(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 mueeHvvbb : public ThObservable {
public:
 
    mueeHvvbb(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, 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 mueeHvvss : public ThObservable {
public:
 
    mueeHvvss(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, 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, 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, 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, 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, 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, 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, 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, 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, const double Pol_em_i, const double Pol_ep_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s, Pol_em, Pol_ep;
};
 
 
//  Production signal strengths at mu+ mu- colliders
//  ------------------------------------------------
 
class mummZH : public ThObservable {
public:
 
    mummZH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
class mummHvv : public ThObservable {
public:
 
    mummHvv(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmm : public ThObservable {
public:
 
    mummHmm(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttH : public ThObservable {
public:
 
    mummttH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
//  Full signal strengths at mu+ mu- colliders
//  -------------------------------------------
 
class mummHbb : public ThObservable {
public:
 
    mummHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHcc : public ThObservable {
public:
 
    mummHcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHgg : public ThObservable {
public:
 
    mummHgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHWW : public ThObservable {
public:
 
    mummHWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHtautau : public ThObservable {
public:
 
    mummHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHZZ : public ThObservable {
public:
 
    mummHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHZga : public ThObservable {
public:
 
    mummHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHgaga : public ThObservable {
public:
 
    mummHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmumu : public ThObservable {
public:
 
    mummHmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHbbNWA : public ThObservable {
public:
 
    mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHccNWA : public ThObservable {
public:
 
    mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHggNWA : public ThObservable {
public:
 
    mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHWWNWA : public ThObservable {
public:
 
    mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHtautauNWA : public ThObservable {
public:
 
    mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHZZNWA : public ThObservable {
public:
 
    mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHZgaNWA : public ThObservable {
public:
 
    mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHgagaNWA : public ThObservable {
public:
 
    mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmumuNWA : public ThObservable {
public:
 
    mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHbb : public ThObservable {
public:
 
    mummZHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHcc : public ThObservable {
public:
 
    mummZHcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHgg : public ThObservable {
public:
 
    mummZHgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHWW : public ThObservable {
public:
 
    mummZHWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHtautau : public ThObservable {
public:
 
    mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHZZ : public ThObservable {
public:
 
    mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHZga : public ThObservable {
public:
 
    mummZHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHgaga : public ThObservable {
public:
 
    mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummZHmumu : public ThObservable {
public:
 
    mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class mummHvvbb : public ThObservable {
public:
 
    mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvcc : public ThObservable {
public:
 
    mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvgg : public ThObservable {
public:
 
    mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvWW : public ThObservable {
public:
 
    mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvtautau : public ThObservable {
public:
 
    mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvZZ : public ThObservable {
public:
 
    mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvZga : public ThObservable {
public:
 
    mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvgaga : public ThObservable {
public:
 
    mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHvvmumu : public ThObservable {
public:
 
    mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
class mummHmmbb : public ThObservable {
public:
 
    mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmcc : public ThObservable {
public:
 
    mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmgg : public ThObservable {
public:
 
    mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmWW : public ThObservable {
public:
 
    mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmtautau : public ThObservable {
public:
 
    mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmZZ : public ThObservable {
public:
 
    mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmZga : public ThObservable {
public:
 
    mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmgaga : public ThObservable {
public:
 
    mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummHmmmumu : public ThObservable {
public:
 
    mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHbb : public ThObservable {
public:
 
    mummttHbb(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHcc : public ThObservable {
public:
 
    mummttHcc(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHgg : public ThObservable {
public:
 
    mummttHgg(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHWW : public ThObservable {
public:
 
    mummttHWW(const StandardModel& SM_i, const double sqrt_s_i);
    
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHtautau : public ThObservable {
public:
 
    mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHZZ : public ThObservable {
public:
 
    mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHZga : public ThObservable {
public:
 
    mummttHZga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHgaga : public ThObservable {
public:
 
    mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
class mummttHmumu : public ThObservable {
public:
 
    mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i);
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
 
 
//  Full signal strengths at ep colliders
//  -------------------------------------
 
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
// -----------------------------------------------------------------------------
 
// -----------------------------------------------------------------------------
// Stage 0
// -----------------------------------------------------------------------------
 
class STXS_0_qqH : public ThObservable {
public:
 
    STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
};
 
 
// -----------------------------------------------------------------------------
// Stage 1
// -----------------------------------------------------------------------------
 
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_nonVHtopo_4l : public ThObservable {
public:
 
    STXSqqHqq_nonVHtopo_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;
};
 
 
 
// -----------------------------------------------------------------------------
// Stage 1.2
// -----------------------------------------------------------------------------
 
 
class STXS12_ggH_pTH200_300_Nj01 : public ThObservable {
public:
 
    STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH300_450_Nj01 : public ThObservable {
public:
 
    STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH450_650_Nj01 : public ThObservable {
public:
 
    STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH650_Inf_Nj01 : public ThObservable {
public:
 
    STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
class STXS12_ggH_pTH10_Inf_Nj0 : public ThObservable {
public:
 
    STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_ggH_pTH0_10_Nj0 : public ThObservable {
public:
 
    STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH10_200_Nj0 : public ThObservable {
public:
 
    STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH0_200_Nj0 : public ThObservable {
public:
 
    STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_ggH_mjj0_350_pTH0_60_Nj1 : public ThObservable {
public:
 
    STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_ggH_pTH0_60_Nj1 : public ThObservable {
public:
 
    STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH60_120_Nj1 : public ThObservable {
public:
 
    STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_pTH120_200_Nj1 : public ThObservable {
public:
 
    STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_ggH_pTH60_200_Nj1 : public ThObservable {
public:
 
    STXS12_ggH_pTH60_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_ggH_mjj0_350_pTH0_60_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_mjj0_350_pTH60_120_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_ggH_mjj0_350_pTH0_120_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_ggH_mjj0_350_pTH120_200_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //AG:added
 
 
 
 
class STXS12_ggH_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
class STXS12_ggH_pTH200_Inf : public ThObservable {
public:
 
    STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
class STXS12_ggH_pTH300_Inf : public ThObservable {
public:
 
    STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
 
class STXS12_ggH_pTH200_300 : public ThObservable {
public:
 
    STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
 
class STXS12_ggH_pTH300_450 : public ThObservable {
public:
 
    STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
class STXS12_ggH_pTH450_650 : public ThObservable {
public:
 
    STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
class STXS12_ggH_pTH650_Inf : public ThObservable {
public:
 
    STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
class STXS12_ggH_pTH450_Inf : public ThObservable {
public:
 
    STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:added
 
 
 
 
class STXS12_ggHpttH : public ThObservable {
public:
 
    STXS12_ggHpttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //AG:added
 
 
class STXS12_ggHll_pTV0_75 : public ThObservable {
public:
 
    STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggHll_pTV75_150 : public ThObservable {
public:
 
    STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggHll_pTV150_250_Nj0 : public ThObservable {
public:
 
    STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggHll_pTV150_250_Nj1 : public ThObservable {
public:
 
    STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_ggHll_pTV250_Inf : public ThObservable {
public:
 
    STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
class STXS12_qqHqq_Nj0 : public ThObservable {
public:
 
    STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_Nj1 : public ThObservable {
public:
 
    STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj0_60_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
class STXS12_qqHqq_mjj60_120_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_qqHqq_VH_veto_Nj01 : public ThObservable {
public:
 
    STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_qqHqq_mjj120_350_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
class STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
 
 
class STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
class STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
}; //VM:Added
 
 
 
 
class STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
class STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
class STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
class STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
class STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
 
 
 
class STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //VM:added
 
 
 
 
 
 
class STXS12_qqHqq_mjj350_Inf_Nj2 : public ThObservable {
public:
 
    STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};      //AG:added
 
 
 
class STXS12_qqHlv_pTV0_75 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHlv_pTV75_150 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHlv_pTV150_250_Nj0 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHlv_pTV150_250_Nj1 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHlv_pTV250_Inf : public ThObservable {
public:
 
    STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHlv_pTV0_150 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
class STXS12_qqHlv_pTV250_400 : public ThObservable {
public:
 
    STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
class STXS12_qqHlv_pTV400_Inf : public ThObservable {
public:
 
    STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
class STXS12_qqHlv_pTV150_Inf : public ThObservable {
public:
 
    STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
 
 
class STXS12_qqHll_pTV0_75 : public ThObservable {
public:
 
    STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHll_pTV75_150 : public ThObservable {
public:
 
    STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHll_pTV0_150 : public ThObservable {
public:
 
    STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
class STXS12_qqHll_pTV150_250_Nj0 : public ThObservable {
public:
 
    STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHll_pTV150_250_Nj1 : public ThObservable {
public:
 
    STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHll_pTV250_Inf : public ThObservable {
public:
 
    STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_qqHll_pTV250_400 : public ThObservable {
public:
 
    STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
class STXS12_qqHll_pTV400_Inf : public ThObservable {
public:
 
    STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
class STXS12_qqHll_pTV150_Inf : public ThObservable {
public:
 
    STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
 
 
 
class STXS12_qqHll : public ThObservable {
public:
 
    STXS12_qqHll(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //VM:added
 
 
 
 
 
 
class STXS12_VHlep : public ThObservable {
public:
 
    STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //AG:added
 
 
 
 
 
 
 
 
 
 
 
 
class STXS12_VHlep_pTV0_150 : public ThObservable {
public:
 
    STXS12_VHlep_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //VM:added
 
 
 
 
 
class STXS12_VHlep_pTV150_Inf : public ThObservable {
public:
 
    STXS12_VHlep_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};            //VM:added
 
 
 
 
 
 
 
class STXS12_ttH_pTH0_60 : public ThObservable {
public:
 
    STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH60_120 : public ThObservable {
public:
 
    STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH0_120 : public ThObservable {
public:
 
    STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH120_200 : public ThObservable {
public:
 
    STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH200_300 : public ThObservable {
public:
 
    STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH300_Inf : public ThObservable {
public:
 
    STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
class STXS12_ttH_pTH300_450 : public ThObservable {
public:
 
    STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
class STXS12_ttH_pTH450_Inf : public ThObservable {
public:
 
    STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
class STXS12_ttH_pTH300_Inf_add : public ThObservable {
public:
 
    STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
class STXS12_ttH : public ThObservable {
public:
 
    STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};              //AG:added
 
 
 
class STXS12_tH : public ThObservable {
public:
 
    STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
 
 
class STXS12_ttH_tH : public ThObservable {
public:
 
    STXS12_ttH_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i);
 
    double computeThValue();
 
private:
    const NPbase* myNPbase;
    const double sqrt_s;
    unsigned int fstate;
};
 
 
 
//-----------------------------------------------------------------------------------------
//-- 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;
};
 
 
 
 
 
 
 
#endif  /* HIGGSTHOBSERVABLES_H */